コード例 #1
0
    def test_Config_file(self):
        methods_needing_args = {
            'inter_gene_max_space': [('set_1/Flagellum', 4),
                                     ('set_1/T2SS', 2)],
            'max_nb_genes': [('set_1/Flagellum', 6), ('set_1/T3SS', 3)],
            'min_genes_required': [('set_1/Flagellum', 8), ('set_1/T4SS', 4)],
            'min_mandatory_genes_required': [('set_1/Flagellum', 12),
                                             ('set_1/T6SS', 6)],
            'multi_loci': {'set_1/Flagellum', 'T4SS'}
        }

        self.parsed_args.cfg_file = self.find_data(
            os.path.join('conf_files', 'macsy_models.conf'))
        cfg = Config(self.defaults, self.parsed_args)

        expected_values = {k: v for k, v in self.defaults.items()}
        expected_values['cfg_file'] = self.parsed_args.cfg_file
        expected_values.update(methods_needing_args)

        for opt, val in expected_values.items():
            if opt == 'out_dir':
                self.assertEqual(
                    cfg.out_dir(),
                    os.path.join(cfg.res_search_dir(),
                                 f'macsyfinder-{strftime("%Y%m%d_%H-%M-%S")}'))
            elif opt == 'multi_loci':
                self.assertTrue(cfg.multi_loci('set_1/Flagellum'))
                self.assertTrue(cfg.multi_loci('set_1/T4SS'))
                self.assertFalse(cfg.multi_loci('set_1/T6SS'))
            elif opt in methods_needing_args:
                for model, genes in expected_values[opt]:
                    self.assertEqual(getattr(cfg, opt)(model), genes)
            else:
                self.assertEqual(getattr(cfg, opt)(), val)
コード例 #2
0
    def test_Config_args(self):
        methods_needing_args = {
            'inter_gene_max_space': [('set_1/Flagellum', '14'),
                                     ('set_1/T2SS', '12')],
            'max_nb_genes': [('set_1/Flagellum', '16'), ('set_1/T3SS', '13')],
            'min_genes_required': [('set_1/Flagellum', '18'),
                                   ('set_1/T4SS', '14')],
            'min_mandatory_genes_required': [('set_1/Flagellum', '22'),
                                             ('set_1/T6SS', '16')],
            'multi_loci':
            'set_1/Flagellum, set_1/T4SS',
        }
        for opt, value in methods_needing_args.items():
            setattr(self.parsed_args, opt, value)

        simple_opt = {
            'hmmer': 'foo',
            'i_evalue_sel': 20,
            'replicon_topology': 'linear',
            'db_type': 'gembase',
            'sequence_db': self.find_data(os.path.join('base',
                                                       'test_1.fasta')),
            'topology_file': __file__  # test only the existence of a file
        }

        for opt, val in simple_opt.items():
            setattr(self.parsed_args, opt, val)

        cfg = Config(self.defaults, self.parsed_args)

        expected_values = {k: v for k, v in self.defaults.items()}
        expected_values.update(methods_needing_args)
        expected_values.update(simple_opt)
        for opt, val in expected_values.items():
            if opt == 'out_dir':
                self.assertEqual(
                    cfg.out_dir(),
                    os.path.join(cfg.res_search_dir(),
                                 f'macsyfinder-{strftime("%Y%m%d_%H-%M-%S")}'))
            elif opt == 'multi_loci':
                self.assertTrue(cfg.multi_loci('set_1/Flagellum'))
                self.assertTrue(cfg.multi_loci('set_1/T4SS'))
                self.assertFalse(cfg.multi_loci('set_1/T6SS'))
            elif opt in methods_needing_args:
                for model, genes in expected_values[opt]:
                    self.assertEqual(getattr(cfg, opt)(model), int(genes))
            elif opt == 'models_dir':
                self.assertEqual(
                    getattr(cfg, opt)(), self.defaults['system_models_dir'])
            else:
                self.assertEqual(
                    getattr(cfg, opt)(),
                    val,
                    msg=
                    f"{opt} failed: expected: val '{val}' != got '{getattr(cfg, opt)()}'"
                )
コード例 #3
0
    def test_Config_file_n_args(self):
        cfg_needing_args = {
            'inter_gene_max_space': [('set_1/Flagellum', '4'),
                                     ('set_1/T2SS', '2')],
            'max_nb_genes': [('set_1/Flagellum', '6'), ('set_1/T3SS', '3')],
            'min_genes_required': [('set_1/Flagellum', '8'),
                                   ('set_1/T4SS', '4')],
            'min_mandatory_genes_required': [('set_1/Flagellum', '12'),
                                             ('set_1/T6SS', '6')],
            'multi_loci':
            'set_1/Flagellum, set_1/T4SS',
        }

        self.parsed_args.cfg_file = self.find_data(
            os.path.join('conf_files', 'macsy_models.conf'))
        expected_values = {k: v for k, v in self.defaults.items()}
        expected_values['cfg_file'] = self.parsed_args.cfg_file
        expected_values.update(cfg_needing_args)

        cmd_needing_args = {
            'min_genes_required': [('set_1/Flagellum', 18), ('T4SS', 14)],
            'min_mandatory_genes_required': [('set_1/Flagellum', 22),
                                             ('set_1/T6SS', 16)],
        }
        for opt, value in cmd_needing_args.items():
            setattr(self.parsed_args, opt,
                    ' '.join([f"{m} {v}" for m, v in value]))

        simple_opt = {'hmmer': 'foo', 'i_evalue_sel': 20, 'db_type': 'gembase'}
        for opt, val in simple_opt.items():
            setattr(self.parsed_args, opt, val)

        cfg = Config(self.defaults, self.parsed_args)

        expected_values.update(cmd_needing_args)
        expected_values.update(simple_opt)

        for opt, exp_val in expected_values.items():
            if opt == 'out_dir':
                self.assertEqual(
                    cfg.out_dir(),
                    os.path.join(cfg.res_search_dir(),
                                 f"macsyfinder-{strftime('%Y%m%d_%H-%M-%S')}"))
            elif opt == 'multi_loci':
                self.assertTrue(cfg.multi_loci('set_1/Flagellum'))
                self.assertTrue(cfg.multi_loci('set_1/T4SS'))
                self.assertFalse(cfg.multi_loci('set_1/T6SS'))
            elif opt in cfg_needing_args:
                for model, val in expected_values[opt]:
                    self.assertEqual(getattr(cfg, opt)(model), int(val))
            elif opt == 'models_dir':
                self.assertEqual(
                    getattr(cfg, opt)(), self.defaults['system_models_dir'])
            else:
                self.assertEqual(getattr(cfg, opt)(), exp_val)
コード例 #4
0
    def test_Config(self):
        cfg = Config(self.defaults, self.parsed_args)
        methods_needing_args = {
            'inter_gene_max_space': None,
            'max_nb_genes': None,
            'min_genes_required': None,
            'min_mandatory_genes_required': None,
            'multi_loci': None
        }

        for opt, val in self.defaults.items():
            if opt == 'out_dir':
                self.assertEqual(
                    cfg.out_dir(),
                    os.path.join(cfg.res_search_dir(),
                                 f'macsyfinder-{strftime("%Y%m%d_%H-%M-%S")}'))
            elif opt == 'multi_loci':
                self.assertFalse(cfg.multi_loci('whatever'))
            elif opt in methods_needing_args:
                self.assertEqual(
                    getattr(cfg, opt)('whatever'),
                    val,
                    msg=
                    f"test of '{opt}' failed : expected{getattr(cfg, opt)('whatever')} !=  got {val}"
                )
            else:
                self.assertEqual(
                    getattr(cfg, opt)(),
                    val,
                    msg=
                    f"test of '{opt}' failed : expected{getattr(cfg, opt)()} !=  got {val}"
                )
コード例 #5
0
    def test_Config_default_conf_file(self):
        methods_needing_args = {
            'inter_gene_max_space': [('set_1/Flagellum', 4),
                                     ('set_1/T2SS', 2)],
            'max_nb_genes': [('set_1/Flagellum', 6), ('set_1/T3SS', 3)],
            'min_genes_required': [('set_1/Flagellum', 8), ('set_1/T4SS', 4)],
            'min_mandatory_genes_required': [('set_1/Flagellum', 12),
                                             ('set_1/T6SS', 6)],
            'multi_loci': {'set_1/Flagellum', 'set_1/T4SS'}
        }
        with tempfile.TemporaryDirectory() as tmpdirname:
            ori_conf_file = self.find_data(
                os.path.join('conf_files', 'macsy_models.conf'))
            dest_conf_file = os.path.join(tmpdirname, 'macsyfinder.conf')
            shutil.copy(ori_conf_file, dest_conf_file)
            os.environ['MACSY_CONF'] = dest_conf_file
            virtual_env = os.environ.get("VIRTUAL_ENV")
            del os.environ["VIRTUAL_ENV"]
            try:
                cfg = Config(self.defaults, self.parsed_args)

                expected_values = {k: v for k, v in self.defaults.items()}
                expected_values.update(methods_needing_args)
                for opt, val in expected_values.items():
                    if opt == 'out_dir':
                        self.assertEqual(
                            cfg.out_dir(),
                            os.path.join(
                                cfg.res_search_dir(),
                                f'macsyfinder-{strftime("%Y%m%d_%H-%M-%S")}'))
                    elif opt == 'multi_loci':
                        self.assertTrue(cfg.multi_loci('set_1/Flagellum'))
                        self.assertTrue(cfg.multi_loci('set_1/T4SS'))
                        self.assertFalse(cfg.multi_loci('set_1/T6SS'))
                    elif opt in methods_needing_args:
                        for model, genes in expected_values[opt]:
                            self.assertEqual(getattr(cfg, opt)(model), genes)
                    elif opt == 'models_dir':
                        self.assertEqual(
                            getattr(cfg, opt)(),
                            self.defaults['system_models_dir'])
                    else:
                        self.assertEqual(getattr(cfg, opt)(), val)
            finally:
                os.environ["VIRTUAL_ENV"] = virtual_env
コード例 #6
0
    def test_project_config_file(self):
        os.chdir(self.tmp_dir)
        methods_needing_args = {
            'inter_gene_max_space': [('set_1/Flagellum', 4),
                                     ('set_1/T2SS', 2)],
            'max_nb_genes': [('set_1/Flagellum', 6), ('set_1/T3SS', 3)],
            'min_genes_required': [('set_1/Flagellum', 8), ('set_1/T4SS', 4)],
            'min_mandatory_genes_required': [('set_1/Flagellum', 12),
                                             ('set_1/T6SS', 6)],
            'multi_loci': {'set_1/Flagellum', 'T4SS'}
        }
        hmmer_opts_in_file = {'coverage_profile': 0.8, 'e_value_search': 0.12}

        try:
            shutil.copyfile(
                self.find_data(os.path.join('conf_files', 'project.conf')),
                os.path.join(self.tmp_dir, 'macsyfinder.conf'))
            cfg = Config(self.defaults, self.parsed_args)

            expected_values = {k: v for k, v in self.defaults.items()}
            expected_values.update(methods_needing_args)
            expected_values.update(hmmer_opts_in_file)

            for opt, val in expected_values.items():
                if opt == 'out_dir':
                    self.assertEqual(
                        cfg.out_dir(),
                        os.path.join(
                            cfg.res_search_dir(),
                            f'macsyfinder-{strftime("%Y%m%d_%H-%M-%S")}'))
                elif opt == 'multi_loci':
                    self.assertTrue(cfg.multi_loci('set_1/Flagellum'))
                    self.assertTrue(cfg.multi_loci('set_1/T4SS'))
                    self.assertFalse(cfg.multi_loci('set_1/T6SS'))
                elif opt in methods_needing_args:
                    for model, genes in expected_values[opt]:
                        self.assertEqual(getattr(cfg, opt)(model), genes)
                elif opt == 'models_dir':
                    self.assertEqual(
                        getattr(cfg, opt)(),
                        self.defaults['system_models_dir'])
                else:
                    self.assertEqual(getattr(cfg, opt)(), val)
        except:
            os.chdir(self._current_dir)
コード例 #7
0
ファイル: test_Config.py プロジェクト: freeh4cker/macsyfinder
class Test(unittest.TestCase):

    _data_dir = os.path.join(os.path.dirname(__file__), "datatest")

    def setUp(self):
        l = logging.getLogger()
        l.manager.loggerDict.clear()
        if hasattr(self, 'cfg'):
            try:
                shutil.rmtree(self.cfg.working_dir)
            except Exception as err:
                pass
        self.tmp_dir = tempfile.gettempdir()

    def tearDown(self):
        logging.shutdown()
        l = logging.getLogger()
        l.manager.loggerDict.clear()
        if hasattr(self, 'cfg'):
            try:
                shutil.rmtree(self.cfg.working_dir)
            except Exception as err:
                pass

    def test_build_indexes(self):
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          res_search_dir=self.tmp_dir)
        self.assertFalse(self.cfg.build_indexes)
        self.tearDown()

        kwargs = {
            'cfg_file': "nimportnaoik",
            'sequence_db': os.path.join(self._data_dir, "base",
                                        "test_base.fa"),
            'db_type': 'gembase',
            'def_dir': os.path.join(self._data_dir, 'DEF'),
            'profile_dir': os.path.join(self._data_dir, 'profiles'),
            'build_indexes': True
        }
        config = Config(cfg_file="nimportnaoik",
                        sequence_db=os.path.join(self._data_dir, "base",
                                                 "test_base.fa"),
                        db_type='gembase',
                        def_dir=os.path.join(self._data_dir, 'DEF'),
                        profile_dir=os.path.join(self._data_dir, 'profiles'),
                        res_search_dir=self.tmp_dir,
                        build_indexes=True)
        self.assertTrue(config.build_indexes)

    def test_default(self):
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.hmmer_exe, 'hmmsearch')

    def test_coverage_profile(self):
        self.cfg = Config(
            cfg_file="nimportnaoik",
            sequence_db=os.path.join(self._data_dir, "base", "test_base.fa"),
            db_type='gembase',
            def_dir=os.path.join(self._data_dir, 'DEF'),
            profile_dir=os.path.join(self._data_dir, 'profiles'),
            res_search_dir=self.tmp_dir,
        )
        self.assertEqual(self.cfg.coverage_profile, 0.5)
        self.tearDown()
        self.cfg = Config(
            cfg_file="nimportnaoik",
            sequence_db=os.path.join(self._data_dir, "base", "test_base.fa"),
            db_type='gembase',
            def_dir=os.path.join(self._data_dir, 'DEF'),
            profile_dir=os.path.join(self._data_dir, 'profiles'),
            coverage_profile=0.6,
            res_search_dir=self.tmp_dir,
        )
        self.assertEqual(self.cfg.coverage_profile, 0.6)
        self.tearDown()
        #coverage_profile must be a float
        kwargs = {
            'cfg_file': "nimportnaoik",
            'sequence_db': os.path.join(self._data_dir, "base",
                                        "test_base.fa"),
            'db_type': 'gembase',
            'def_dir': os.path.join(self._data_dir, 'DEF'),
            'profile_dir': os.path.join(self._data_dir, 'profiles'),
            'coverage_profile': "foo",
            'res_search_dir': self.tmp_dir
        }
        self.assertRaises(ValueError, Config, **kwargs)

    def test_def_dir(self):
        kwargs = {
            'cfg_file': "nimportnaoik",
            'sequence_db': os.path.join(self._data_dir, "base",
                                        "test_base.fa"),
            'db_type': 'gembase',
            'profile_dir': os.path.join(self._data_dir, 'profiles'),
            'def_dir': '/kjhdsjkg938268235764kjdsg',
            'res_search_dir': self.tmp_dir
        }
        real_def_dir = os.path.join(os.path.dirname(__file__), '..', 'data',
                                    'DEF'),
        self.assertRaises(ValueError, Config, **kwargs)

        def_dir = os.path.join(tempfile.gettempdir(), 'macsyfinder_DEF')
        if not os.path.exists(def_dir):
            os.mkdir(def_dir)
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=def_dir,
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          res_search_dir=self.tmp_dir)
        self.assertEqual(def_dir, self.cfg.def_dir)
        shutil.rmtree(def_dir)
        self.tearDown()
        def_dir = os.path.join(os.path.dirname(__file__), '..', 'data', 'DEF')
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=def_dir,
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          res_search_dir=self.tmp_dir)
        self.assertEqual(def_dir, self.cfg.def_dir)

    def test_e_value_res(self):
        kwargs = {
            'cfg_file': "nimportnaoik",
            'sequence_db': os.path.join(self._data_dir, "base",
                                        "test_base.fa"),
            'db_type': 'gembase',
            'def_dir': os.path.join(self._data_dir, 'DEF'),
            'profile_dir': os.path.join(self._data_dir, 'profiles'),
            'e_value_res': 'foo',
            'res_search_dir': self.tmp_dir
        }
        self.assertRaises(ValueError, Config, **kwargs)
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.e_value_res, 1)
        self.tearDown()
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          e_value_res=0.7,
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.e_value_res, 0.7)
        self.tearDown()
        kwargs = {
            'cfg_file': "nimportnaoik",
            'sequence_db': os.path.join(self._data_dir, "base",
                                        "test_base.fa"),
            'db_type': 'gembase',
            'def_dir': os.path.join(self._data_dir, 'DEF'),
            'profile_dir': os.path.join(self._data_dir, 'profiles'),
            'e_value_res': 0.7,
            'i_evalue_sel': 1,
            'res_search_dir': self.tmp_dir
        }
        self.assertRaises(ValueError, Config, **kwargs)

    def test_hmmer_exe(self):
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.hmmer_exe, 'hmmsearch')
        self.tearDown()
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          hmmer_exe='truc',
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.hmmer_exe, 'truc')

    def test_index_db_exe(self):
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.index_db_exe, 'makeblastdb')
        self.tearDown()
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          index_db_exe='truc',
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.index_db_exe, 'truc')

    def test_i_value_sel(self):
        kwargs = {
            'cfg_file': "nimportnaoik",
            'sequence_db': os.path.join(self._data_dir, "base",
                                        "test_base.fa"),
            'db_type': 'gembase',
            'def_dir': os.path.join(self._data_dir, 'DEF'),
            'profile_dir': os.path.join(self._data_dir, 'profiles'),
            'i_evalue_sel': 'foo',
            'res_search_dir': self.tmp_dir
        }
        self.assertRaises(ValueError, Config, **kwargs)
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.i_evalue_sel, 0.001)
        self.tearDown()
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          i_evalue_sel=0.7,
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.i_evalue_sel, 0.7)
        self.tearDown()
        kwargs = {
            'cfg_file': "nimportnaoik",
            'sequence_db': os.path.join(self._data_dir, "base",
                                        "test_base.fa"),
            'db_type': 'gembase',
            'def_dir': os.path.join(self._data_dir, 'DEF'),
            'profile_dir': os.path.join(self._data_dir, 'profiles'),
            'e_value_res': 0.7,
            'i_evalue_sel': 1,
            'res_search_dir': self.tmp_dir
        }
        self.assertRaises(ValueError, Config, **kwargs)

    def test_db_type(self):
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.db_type, 'gembase')
        self.tearDown()
        kwargs = {
            'cfg_file': "nimportnaoik",
            'sequence_db': os.path.join(self._data_dir, "base",
                                        "test_base.fa"),
            'db_type': 'foo',
            'def_dir': os.path.join(self._data_dir, 'DEF'),
            'profile_dir': os.path.join(self._data_dir, 'profiles'),
            'res_search_dir': self.tmp_dir
        }
        self.assertRaises(ValueError, Config, **kwargs)

    def test_previous_run(self):
        out_dir = os.path.join(self.tmp_dir, 'macsy_test_config')
        kwargs = {
            'cfg_file': "nimportnaoik",
            'sequence_db': os.path.join(self._data_dir, "base",
                                        "test_base.fa"),
            'db_type': 'gembase',
            'def_dir': os.path.join(self._data_dir, 'DEF'),
            'profile_dir': os.path.join(self._data_dir, 'profiles'),
            'previous_run': 'foo',
            'res_search_dir': out_dir
        }
        self.assertRaises(ValueError, Config, **kwargs)
        try:
            shutil.rmtree(out_dir)
        except:
            pass
        self.tearDown()
        try:
            cfg_base = Config(cfg_file="nimportnaoik",
                              sequence_db=os.path.join(self._data_dir, "base",
                                                       "test_base.fa"),
                              db_type='gembase',
                              def_dir=os.path.join(self._data_dir, 'DEF'),
                              profile_dir=os.path.join(self._data_dir,
                                                       'profiles'),
                              res_search_dir=self.tmp_dir)
            self.assertIsNone(cfg_base.previous_run)
            cfg_base.save(cfg_base.working_dir)
            #wait
            time.sleep(1)
            new_cfg = Config(previous_run=cfg_base.working_dir)
            self.assertEqual(new_cfg.previous_run, cfg_base.working_dir)

        finally:

            # close loggers filehandles, so they don't block file deletion
            # in shutil.rmtree calls in Windows
            logging.shutdown()
            try:
                shutil.rmtree(new_cfg.working_dir)
            except:
                pass
            try:
                shutil.rmtree(cfg_base.working_dir)
            except:
                pass

    def test_profile_dir(self):
        kwargs = {
            'cfg_file': "nimportnaoik",
            'sequence_db': os.path.join(self._data_dir, "base",
                                        "test_base.fa"),
            'db_type': 'gembase',
            'def_dir': os.path.join(self._data_dir, 'DEF'),
            'profile_dir': 'foo',
            'res_search_dir': self.tmp_dir
        }
        self.assertRaises(ValueError, Config, **kwargs)
        profile_dir = os.path.join(os.path.dirname(__file__), '..', 'data',
                                   'profiles')
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=profile_dir,
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.profile_dir, profile_dir)

    def test_profile_suffix(self):
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.profile_suffix, '.hmm')
        self.tearDown()
        profile_suffix = 'foo'
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          profile_suffix=profile_suffix,
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.profile_suffix, profile_suffix)

    def test_replicon_topology(self):
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.replicon_topology, 'circular')
        self.tearDown()
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          replicon_topology='linear',
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.replicon_topology, 'linear')
        self.tearDown()
        kwargs = {
            'cfg_file': "nimportnaoik",
            'sequence_db': os.path.join(self._data_dir, "base",
                                        "test_base.fa"),
            'db_type': 'gembase',
            'def_dir': os.path.join(self._data_dir, 'DEF'),
            'profile_dir': os.path.join(self._data_dir, 'profiles'),
            'replicon_topology': 'foo',
            'res_search_dir': self.tmp_dir
        }
        self.assertRaises(ValueError, Config, **kwargs)

    def test_inter_gene_max_space(self):
        inter_gene_max_space = (["T2SS", 32], ['Flagellum', 64])
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          inter_gene_max_space=inter_gene_max_space,
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.inter_gene_max_space('T2SS'), 32)
        self.assertEqual(self.cfg.inter_gene_max_space('Flagellum'), 64)
        self.assertIsNone(self.cfg.inter_gene_max_space('Foo'))

    def test_min_genes_required(self):
        min_genes_required = (["T2SS", 32], ['Flagellum', 64])
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          min_genes_required=min_genes_required,
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.min_genes_required('T2SS'), 32)
        self.assertEqual(self.cfg.min_genes_required('Flagellum'), 64)
        self.assertIsNone(self.cfg.min_genes_required('Foo'))

    def test_max_nb_genes(self):
        max_nb_genes = (["T2SS", 32], ['Flagellum', 64])
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          max_nb_genes=max_nb_genes,
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.max_nb_genes('T2SS'), 32)
        self.assertEqual(self.cfg.max_nb_genes('Flagellum'), 64)
        self.assertIsNone(self.cfg.max_nb_genes('Foo'))

    def test_min_mandatory_genes_required(self):
        min_mandatory_genes_required = (["T2SS", 32], ['Flagellum', 64])
        self.cfg = Config(
            cfg_file="nimportnaoik",
            sequence_db=os.path.join(self._data_dir, "base", "test_base.fa"),
            db_type='gembase',
            def_dir=os.path.join(self._data_dir, 'DEF'),
            profile_dir=os.path.join(self._data_dir, 'profiles'),
            min_mandatory_genes_required=min_mandatory_genes_required,
            res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.min_mandatory_genes_required('T2SS'), 32)
        self.assertEqual(self.cfg.min_mandatory_genes_required('Flagellum'),
                         64)
        self.assertIsNone(self.cfg.min_mandatory_genes_required('Foo'))

    def test_multi_loci(self):
        multi_loci = "T2SS,Flagellum"
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          multi_loci=multi_loci,
                          res_search_dir=self.tmp_dir)
        self.assertTrue(self.cfg.multi_loci('T2SS'))
        self.assertTrue(self.cfg.multi_loci('Flagellum'))
        self.assertFalse(self.cfg.multi_loci('Foo'))

    def test_res_extract_suffix(self):
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.res_extract_suffix, '.res_hmm_extract')
        self.tearDown()
        res_extract_suffix = 'foo'
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          res_extract_suffix=res_extract_suffix,
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.res_extract_suffix, res_extract_suffix)

    def test_res_search_dir(self):
        kwargs = {
            'cfg_file': "nimportnaoik",
            'sequence_db': os.path.join(self._data_dir, "base",
                                        "test_base.fa"),
            'db_type': 'gembase',
            'def_dir': os.path.join(self._data_dir, 'DEF'),
            'profile_dir': os.path.join(self._data_dir, 'profiles'),
            'res_search_dir': 'foo',
            'log_file':
            'NUL' if platform.system() == 'Windows' else '/dev/null'
        }
        self.assertRaises(ValueError, Config, **kwargs)
        self.tearDown()
        res_search_dir = os.path.join(os.path.dirname(__file__), 'datatest')
        self.cfg = Config(
            cfg_file="nimportnaoik",
            sequence_db=os.path.join(self._data_dir, "base", "test_base.fa"),
            db_type='gembase',
            def_dir=os.path.join(self._data_dir, 'DEF'),
            profile_dir=os.path.join(self._data_dir, 'profiles'),
            res_search_dir=res_search_dir,
            log_file='NUL' if platform.system() == 'Windows' else '/dev/null')
        self.assertEqual(self.cfg.res_search_dir, res_search_dir)

    def test_out_dir(self):
        out_dir = os.path.join(self.tmp_dir, 'macsy_test_config')
        try:
            shutil.rmtree(out_dir)
        except:
            pass
        os.makedirs(out_dir, 0775)
        f = open(os.path.join(out_dir, 'fake'), 'w')
        f.close()
        kwargs = {
            'cfg_file': "nimportnaoik",
            'sequence_db': os.path.join(self._data_dir, "base",
                                        "test_base.fa"),
            'db_type': 'gembase',
            'def_dir': os.path.join(self._data_dir, 'DEF'),
            'profile_dir': os.path.join(self._data_dir, 'profiles'),
            'out_dir': out_dir,
            'log_file':
            'NUL' if platform.system() == 'Windows' else '/dev/null'
        }
        self.assertRaises(ValueError, Config, **kwargs)
        shutil.rmtree(out_dir)
        self.tearDown()

        os.makedirs(out_dir, 0775)
        self.cfg = Config(
            cfg_file="nimportnaoik",
            sequence_db=os.path.join(self._data_dir, "base", "test_base.fa"),
            db_type='gembase',
            def_dir=os.path.join(self._data_dir, 'DEF'),
            profile_dir=os.path.join(self._data_dir, 'profiles'),
            out_dir=out_dir,
            log_file='NUL' if platform.system() == 'Windows' else '/dev/null')
        self.assertEqual(self.cfg.working_dir, out_dir)

    def test_res_search_suffix(self):
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(os.path.dirname(__file__), '..',
                                               'data', 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.res_search_suffix, '.search_hmm.out')
        self.tearDown()
        res_search_suffix = 'foo'
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          res_search_suffix=res_search_suffix,
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.res_search_suffix, res_search_suffix)

    def test_sequence_db(self):
        kwargs = {
            'cfg_file': "nimportnaoik",
            'db_type': 'gembase',
            'def_dir': os.path.join(self._data_dir, 'DEF'),
            'profile_dir': os.path.join(self._data_dir, 'profiles'),
            'worker_nb': '2.3',
            'res_search_dir': self.tmp_dir,
            'log_file':
            'NUL' if platform.system() == 'Windows' else '/dev/null'
        }

        self.assertRaises(ValueError, Config, **kwargs)
        kwargs = {
            'cfg_file': "nimportnaoik",
            'sequence_db': "foo",
            'db_type': 'gembase',
            'def_dir': os.path.join(self._data_dir, 'DEF'),
            'profile_dir': os.path.join(self._data_dir, 'profiles'),
            'worker_nb': '2.3',
            'res_search_dir': self.tmp_dir,
            'log_file':
            'NUL' if platform.system() == 'Windows' else '/dev/null'
        }
        self.assertRaises(ValueError, Config, **kwargs)
        sequence_db = os.path.join(self._data_dir, "base", "test_base.fa")
        self.cfg = Config(
            cfg_file="nimportnaoik",
            sequence_db=sequence_db,
            db_type='gembase',
            def_dir=os.path.join(self._data_dir, 'DEF'),
            profile_dir=os.path.join(self._data_dir, 'profiles'),
            res_search_dir=self.tmp_dir,
            log_file='NUL' if platform.system() == 'Windows' else '/dev/null')
        self.assertEqual(self.cfg.sequence_db, sequence_db)

    def test_worker_nb(self):
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          res_search_dir=self.tmp_dir)
        self.assertEqual(self.cfg.worker_nb, 1)
        self.tearDown()
        self.cfg = Config(cfg_file="nimportnaoik",
                          sequence_db=os.path.join(self._data_dir, "base",
                                                   "test_base.fa"),
                          db_type='gembase',
                          def_dir=os.path.join(self._data_dir, 'DEF'),
                          profile_dir=os.path.join(self._data_dir, 'profiles'),
                          res_search_dir=self.tmp_dir,
                          worker_nb=2)
        self.assertEqual(self.cfg.worker_nb, 2)
        self.tearDown()
        kwargs = {
            'cfg_file': "nimportnaoik",
            'sequence_db': os.path.join(self._data_dir, "base",
                                        "test_base.fa"),
            'db_type': 'gembase',
            'def_dir': os.path.join(self._data_dir, 'DEF'),
            'profile_dir': os.path.join(self._data_dir, 'profiles'),
            'res_search_dir': self.tmp_dir,
            'worker_nb': '2.3'
        }
        self.assertRaises(ValueError, Config, **kwargs)
コード例 #8
0
ファイル: test_Config.py プロジェクト: fjossandon/macsyfinder
class Test(unittest.TestCase):

    _data_dir = os.path.join(os.path.dirname(__file__), "datatest")
    
    def setUp(self):
        l = logging.getLogger()
        l.manager.loggerDict.clear()
        if hasattr(self, 'tmp_dir'):
            try:
                shutil.rmtree(self.cfg.working_dir)
            except Exception as err:
                pass
        self.tmp_dir = tempfile.gettempdir()
        
        
    def tearDown(self):
        logging.shutdown()
        l = logging.getLogger()
        l.manager.loggerDict.clear()
        if hasattr(self, 'cfg'):
            try:
                shutil.rmtree(self.cfg.working_dir)
            except Exception as err:
                pass


    def test_build_indexes(self):
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = self.tmp_dir
                          )
        self.assertFalse(self.cfg.build_indexes)
        self.tearDown()
         
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'build_indexes' : True
        }
        config = Config(
                        cfg_file = "nimportnaoik",
                        sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                        db_type = 'gembase',
                        def_dir = os.path.join(self._data_dir, 'DEF'),
                        profile_dir = os.path.join(self._data_dir, 'profiles'),
                        res_search_dir = self.tmp_dir,
                        build_indexes = True
                        )
        self.assertTrue(config.build_indexes)
 
 
    def test_default(self):
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = self.tmp_dir
                          )
        self.assertEqual(self.cfg.hmmer_exe, 'hmmsearch')
 
 
    def test_coverage_profile(self):
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = self.tmp_dir,
                          )
        self.assertEqual( self.cfg.coverage_profile, 0.5 )
        self.tearDown()
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          coverage_profile = 0.6,
                          res_search_dir = self.tmp_dir,
                          )
        self.assertEqual( self.cfg.coverage_profile, 0.6 )
        self.tearDown()
        #coverage_profile must be a float
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'coverage_profile' : "foo",
                  'res_search_dir' : self.tmp_dir
        }
        self.assertRaises(ValueError, Config, **kwargs)
 
 
    def test_def_dir(self):
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'def_dir': '/kjhdsjkg938268235764kjdsg',
                  'res_search_dir' : self.tmp_dir
                  }
        real_def_dir = os.path.join(os.path.dirname(__file__), '..', 'data', 'DEF'),
        self.assertRaises(ValueError, Config, **kwargs)
 
        def_dir = os.path.join(tempfile.gettempdir(), 'macsyfinder_DEF')
        if not os.path.exists(def_dir):
            os.mkdir(def_dir)
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = def_dir,
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = self.tmp_dir
                          ) 
        self.assertEqual(def_dir, self.cfg.def_dir)
        shutil.rmtree(def_dir)
        self.tearDown()
        def_dir = os.path.join(os.path.dirname(__file__),'..', 'data',  'DEF')
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = def_dir,
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = self.tmp_dir
                          )  
        self.assertEqual(def_dir, self.cfg.def_dir)


    def test_e_value_res(self):
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'e_value_res' : 'foo',
                  'res_search_dir' : self.tmp_dir
        }
        self.assertRaises(ValueError, Config, **kwargs)
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = self.tmp_dir
                          )
        self.assertEqual(self.cfg.e_value_res, 1)
        self.tearDown()
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          e_value_res = 0.7,
                          res_search_dir = self.tmp_dir
                          )
        self.assertEqual(self.cfg.e_value_res, 0.7)
        self.tearDown()
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'e_value_res' : 0.7,
                  'i_evalue_sel' : 1,
                  'res_search_dir' : self.tmp_dir
        }
        self.assertRaises(ValueError, Config, **kwargs)
 
 
    def test_hmmer_exe(self):
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = self.tmp_dir
                          )
        self.assertEqual(self.cfg.hmmer_exe, 'hmmsearch')
        self.tearDown()
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          hmmer_exe = 'truc',
                          res_search_dir = self.tmp_dir
                          )
        self.assertEqual(self.cfg.hmmer_exe, 'truc')
 
 
    def test_index_db_exe(self):
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = self.tmp_dir
                          )
        self.assertEqual(self.cfg.index_db_exe, 'makeblastdb')
        self.tearDown()
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          index_db_exe = 'truc',
                          res_search_dir = self.tmp_dir
                          )
        self.assertEqual(self.cfg.index_db_exe, 'truc')
 
 
    def test_i_value_sel(self):
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'i_evalue_sel' : 'foo',
                  'res_search_dir' : self.tmp_dir
        }
        self.assertRaises(ValueError, Config, **kwargs)
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = self.tmp_dir
                          )
        self.assertEqual(self.cfg.i_evalue_sel, 0.001)
        self.tearDown()
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          i_evalue_sel = 0.7,
                          res_search_dir = self.tmp_dir
                          )
        self.assertEqual(self.cfg.i_evalue_sel, 0.7)
        self.tearDown()
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'e_value_res' : 0.7,
                  'i_evalue_sel' : 1,
                  'res_search_dir' : self.tmp_dir
        }
        self.assertRaises(ValueError, Config, **kwargs)


    def test_db_type(self):
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = self.tmp_dir
                          )
        self.assertEqual( self.cfg.db_type, 'gembase')
        self.tearDown()
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'foo',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'res_search_dir' : self.tmp_dir
        }
        self.assertRaises(ValueError, Config, **kwargs)


    def test_previous_run(self):
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'previous_run' : 'foo',
                  'res_search_dir' : self.tmp_dir
        }
        self.assertRaises(ValueError, Config, **kwargs)
        try:
            cfg_base = Config(cfg_file = "nimportnaoik",
                              sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                              db_type = 'gembase',
                              def_dir = os.path.join(self._data_dir, 'DEF'),
                              profile_dir = os.path.join(self._data_dir, 'profiles'),
                              res_search_dir = self.tmp_dir
                              )
            self.assertIsNone(cfg_base.previous_run)
            cfg_base.save( cfg_base.working_dir )
            #wait
            time.sleep(1)
            new_cfg = Config(previous_run = cfg_base.working_dir)
            self.assertEqual(new_cfg.previous_run, cfg_base.working_dir)
             
        finally:
             
            # close loggers filehandles, so they don't block file deletion
            # in shutil.rmtree calls in Windows
            logging.shutdown()
            try:
                shutil.rmtree(new_cfg.working_dir)
            except:
                pass
         
        
        
    def test_profile_dir(self):
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : 'foo',
                  'res_search_dir' : self.tmp_dir
        }
        self.assertRaises(ValueError, Config, **kwargs)
        profile_dir = os.path.join(os.path.dirname(__file__), '..', 'data', 'profiles')
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = profile_dir,
                          res_search_dir = self.tmp_dir
                          )
        self.assertEqual(self.cfg.profile_dir, profile_dir)
  
 
    def test_profile_suffix(self):
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = self.tmp_dir
                          )
        self.assertEqual(self.cfg.profile_suffix, '.hmm')
        self.tearDown()
        profile_suffix = 'foo'
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          profile_suffix = profile_suffix,
                          res_search_dir = self.tmp_dir
                          )
        self.assertEqual(self.cfg.profile_suffix, profile_suffix)
  
 
    def test_replicon_topology(self):
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = self.tmp_dir
                          )
        self.assertEqual(self.cfg.replicon_topology, 'circular')
        self.tearDown()
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          replicon_topology = 'linear',
                          res_search_dir = self.tmp_dir
                          )
        self.assertEqual(self.cfg.replicon_topology, 'linear')
        self.tearDown()
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'replicon_topology' : 'foo',
                  'res_search_dir' : self.tmp_dir
        }
        self.assertRaises(ValueError, Config, **kwargs)


    def test_inter_gene_max_space(self):
        inter_gene_max_space = (["T2SS", 32], ['Flagellum', 64])
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          inter_gene_max_space = inter_gene_max_space,
                          res_search_dir = self.tmp_dir
                          )
        self.assertEqual(self.cfg.inter_gene_max_space('T2SS'), 32)
        self.assertEqual(self.cfg.inter_gene_max_space('Flagellum'), 64)
        self.assertIsNone(self.cfg.inter_gene_max_space('Foo'))


    def test_min_genes_required(self):
        min_genes_required = (["T2SS", 32], ['Flagellum', 64])
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          min_genes_required = min_genes_required,
                          res_search_dir = self.tmp_dir
                          )
        self.assertEqual(self.cfg.min_genes_required('T2SS'), 32)
        self.assertEqual(self.cfg.min_genes_required('Flagellum'), 64)
        self.assertIsNone(self.cfg.min_genes_required('Foo'))

    def test_max_nb_genes(self):
        max_nb_genes = (["T2SS", 32], ['Flagellum', 64])
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          max_nb_genes = max_nb_genes,
                          res_search_dir = self.tmp_dir
                          )
        self.assertEqual(self.cfg.max_nb_genes('T2SS'), 32)
        self.assertEqual(self.cfg.max_nb_genes('Flagellum'), 64)
        self.assertIsNone(self.cfg.max_nb_genes('Foo'))


    def test_min_mandatory_genes_required(self):
        min_mandatory_genes_required = (["T2SS", 32], ['Flagellum', 64])
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          min_mandatory_genes_required = min_mandatory_genes_required,
                          res_search_dir = self.tmp_dir
                          )
        self.assertEqual(self.cfg.min_mandatory_genes_required('T2SS'), 32)
        self.assertEqual(self.cfg.min_mandatory_genes_required('Flagellum'), 64)
        self.assertIsNone(self.cfg.min_mandatory_genes_required('Foo'))
           
         
    def test_multi_loci(self):
        multi_loci = "T2SS,Flagellum"
        self.cfg = Config(cfg_file = "nimportnaoik",
                         sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                         db_type = 'gembase',
                         def_dir = os.path.join(self._data_dir, 'DEF'),
                         profile_dir = os.path.join(self._data_dir, 'profiles'),
                         multi_loci = multi_loci,
                         res_search_dir = self.tmp_dir 
                         )
        self.assertTrue(self.cfg.multi_loci('T2SS'))
        self.assertTrue(self.cfg.multi_loci('Flagellum'))
        self.assertFalse(self.cfg.multi_loci('Foo'))
          
 
    def test_res_extract_suffix(self):
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = self.tmp_dir 
                          )
        self.assertEqual(self.cfg.res_extract_suffix, '.res_hmm_extract')
        self.tearDown()
        res_extract_suffix = 'foo'
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_extract_suffix = res_extract_suffix,
                          res_search_dir = self.tmp_dir 
                          )
        self.assertEqual(self.cfg.res_extract_suffix, res_extract_suffix)
            
           
    def test_res_search_dir(self):
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'res_search_dir' : 'foo',
                  'log_file' : 'NUL' if platform.system() == 'Windows' else '/dev/null'
        }
        self.assertRaises(ValueError, Config, **kwargs)
        self.tearDown()
        res_search_dir = os.path.join(os.path.dirname(__file__), 'datatest')
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = res_search_dir,
                          log_file = 'NUL' if platform.system() == 'Windows' else '/dev/null'
                          )
        self.assertEqual(self.cfg.res_search_dir, res_search_dir)
    
  
    def test_res_search_suffix(self):
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(os.path.dirname(__file__),'..', 'data',  'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = self.tmp_dir
                          )
        self.assertEqual(self.cfg.res_search_suffix, '.search_hmm.out')
        self.tearDown()
        res_search_suffix = 'foo'
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_suffix = res_search_suffix,
                          res_search_dir = self.tmp_dir
                          )
        self.assertEqual(self.cfg.res_search_suffix, res_search_suffix)
       
       
    def test_sequence_db(self):
        kwargs = {'cfg_file' : "nimportnaoik",
                   'db_type' : 'gembase',
                   'def_dir' : os.path.join(self._data_dir, 'DEF'),
                   'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                   'worker_nb' : '2.3' ,
                   'res_search_dir' : self.tmp_dir,
                   'log_file' : 'NUL' if platform.system() == 'Windows' else '/dev/null'
        }
         
        self.assertRaises(ValueError, Config, **kwargs)  
        kwargs = {'cfg_file' : "nimportnaoik",
                   'sequence_db' : "foo",
                   'db_type' : 'gembase',
                   'def_dir' : os.path.join(self._data_dir, 'DEF'),
                   'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                   'worker_nb' : '2.3',
                   'res_search_dir' : self.tmp_dir,
                   'log_file' : 'NUL' if platform.system() == 'Windows' else '/dev/null'
        }
        self.assertRaises(ValueError, Config, **kwargs) 
        sequence_db = os.path.join(self._data_dir, "base", "test_base.fa")
        self.cfg = Config(cfg_file = "nimportnaoik",
                           sequence_db = sequence_db,
                           db_type = 'gembase',
                           def_dir = os.path.join(self._data_dir, 'DEF'),
                           profile_dir = os.path.join(self._data_dir, 'profiles'),
                           res_search_dir = self.tmp_dir,
                           log_file = 'NUL' if platform.system() == 'Windows' else '/dev/null'
                           )  
        self.assertEqual(self.cfg.sequence_db, sequence_db)
   
 
    def test_worker_nb(self):
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = self.tmp_dir
                          )
        self.assertEqual(self.cfg.worker_nb, 1)
        self.tearDown()
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = self.tmp_dir,
                          worker_nb = 2
                          )
        self.assertEqual(self.cfg.worker_nb, 2)
        self.tearDown()
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'res_search_dir' : self.tmp_dir,
                  'worker_nb' : '2.3'
        }
        self.assertRaises(ValueError, Config, **kwargs)   
コード例 #9
0
class Test(unittest.TestCase):

    _data_dir = os.path.join(os.path.dirname(__file__), "datatest")

    def tearDown(self):
        try:
            shutil.rmtree(self.cfg.working_dir)
        except:
            pass

    def test_build_indexes(self):
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = '/tmp'
                          )
        self.assertFalse(self.cfg.build_indexes)
        self.tearDown()
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'build_indexes' : True
        }
        config = Config(
                        cfg_file = "nimportnaoik",
                        sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                        db_type = 'gembase',
                        def_dir = os.path.join(self._data_dir, 'DEF'),
                        profile_dir = os.path.join(self._data_dir, 'profiles'),
                        res_search_dir = '/tmp',
                        build_indexes = True
                        )
        self.assertTrue(config.build_indexes)


    def test_default(self):
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = '/tmp'
                          )
        self.assertEqual(self.cfg.hmmer_exe, 'hmmsearch')


    def test_coverage_profile(self):
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = '/tmp',
                          )
        self.assertEqual( self.cfg.coverage_profile, 0.5 )
        self.tearDown()
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          coverage_profile = 0.6,
                          res_search_dir = '/tmp',
                          )
        self.assertEqual( self.cfg.coverage_profile, 0.6 )
        self.tearDown()
        #coverage_profile must be a float
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'coverage_profile' : "foo",
                  'res_search_dir' : '/tmp'
        }
        self.assertRaises(ValueError, Config, **kwargs)


    def test_def_dir(self):
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'def_dir': '/kjhdsjkg938268235764kjdsg',
                  'res_search_dir' : '/tmp',
                  }
        real_def_dir = os.path.join(os.path.dirname(__file__), '..', 'data', 'DEF'),
        self.assertRaises(ValueError, Config, **kwargs)

        def_dir = os.path.join('/tmp', 'macsyfinder_DEF')
        if not os.path.exists(def_dir):
            os.mkdir(def_dir)
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = def_dir,
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = '/tmp',
                          ) 
        self.assertEqual(def_dir, self.cfg.def_dir)
        shutil.rmtree(def_dir)
        self.tearDown()
        def_dir = os.path.join(os.path.dirname(__file__),'..', 'data',  'DEF')
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = def_dir,
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = '/tmp',
                          )  
        self.assertEqual( def_dir, self.cfg.def_dir)


    def test_e_value_res(self):
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'e_value_res' : 'foo',
                  'res_search_dir' : '/tmp'
        }
        self.assertRaises(ValueError, Config, **kwargs)
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = '/tmp'
                          )
        self.assertEqual(self.cfg.e_value_res, 1)
        self.tearDown()
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          e_value_res = 0.7,
                          res_search_dir = '/tmp',
                          )
        self.assertEqual(self.cfg.e_value_res, 0.7)
        self.tearDown()
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'e_value_res' : 0.7,
                  'i_evalue_sel' : 1,
                  'res_search_dir' : '/tmp',
        }
        self.assertRaises(ValueError, Config, **kwargs)


    def test_hmmer_exe(self):
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = '/tmp'
                          )
        self.assertEqual(self.cfg.hmmer_exe, 'hmmsearch')
        self.tearDown()
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          hmmer_exe = 'truc',
                          res_search_dir = '/tmp',
                          )
        self.assertEqual(self.cfg.hmmer_exe, 'truc')


    def test_index_db_exe(self):
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = '/tmp'
                          )
        self.assertEqual(self.cfg.index_db_exe, 'makeblastdb')
        self.tearDown()
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          index_db_exe = 'truc',
                          res_search_dir = '/tmp',
                          )
        self.assertEqual(self.cfg.index_db_exe, 'truc')


    def test_i_value_sel(self):
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'i_evalue_sel' : 'foo',
                  'res_search_dir' : '/tmp',
        }
        self.assertRaises(ValueError, Config, **kwargs)
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = '/tmp'
                          )
        self.assertEqual(self.cfg.i_evalue_sel, 0.001)
        self.tearDown()
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          i_evalue_sel = 0.7,
                          res_search_dir = '/tmp',
                          )
        self.assertEqual(self.cfg.i_evalue_sel, 0.7)
        self.tearDown()
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'e_value_res' : 0.7,
                  'i_evalue_sel' : 1,
                  'res_search_dir' : '/tmp',
        }
        self.assertRaises(ValueError, Config, **kwargs)


    def test_db_type(self):
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = '/tmp',
                          )
        self.assertEqual( self.cfg.db_type, 'gembase')
        self.tearDown()
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'foo',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'res_search_dir' : '/tmp',
        }
        self.assertRaises(ValueError, Config, **kwargs)


    def test_previous_run(self):
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'previous_run' : 'foo',
                  'res_search_dir' : '/tmp',
        }
        self.assertRaises(ValueError, Config, **kwargs)
        try:
            cfg_base = Config(cfg_file = "nimportnaoik",
                              sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                              db_type = 'gembase',
                              def_dir = os.path.join(self._data_dir, 'DEF'),
                              profile_dir = os.path.join(self._data_dir, 'profiles'),
                              res_search_dir = '/tmp',
                              )
            self.assertIsNone(cfg_base.previous_run)
            cfg_base.save( cfg_base.working_dir )
            #wait
            time.sleep(1)
            new_cfg = Config(previous_run = cfg_base.working_dir)
            self.assertEqual(new_cfg.previous_run, cfg_base.working_dir)
        finally:
            try:
                shutil.rmtree(cfg_base.working_dir)
            except:
                pass
            try:
                shutil.rmtree(new_cfg.working_dir)
            except:
                pass


    def test_profile_dir(self):
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : 'foo',
                  'res_search_dir' : '/tmp',
        }
        self.assertRaises(ValueError, Config, **kwargs)
        profile_dir = os.path.join(os.path.dirname(__file__), '..', 'data', 'profiles')
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = profile_dir,
                          res_search_dir = '/tmp',
                          )
        self.assertEqual(self.cfg.profile_dir , profile_dir)


    def test_profile_suffix(self):
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = '/tmp'
                          )
        self.assertEqual(self.cfg.profile_suffix, '.hmm')
        self.tearDown()
        profile_suffix = 'foo'
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          profile_suffix = profile_suffix,
                          res_search_dir = '/tmp',
                          )
        self.assertEqual(self.cfg.profile_suffix, profile_suffix)


    def test_replicon_topology(self):
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = '/tmp',
                          )
        self.assertEqual(self.cfg.replicon_topology, 'circular')
        self.tearDown()
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          replicon_topology = 'linear',
                          res_search_dir = '/tmp',
                          )
        self.assertEqual(self.cfg.replicon_topology, 'linear')
        self.tearDown()
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'replicon_topology' : 'foo'
        }
        self.assertRaises(ValueError, Config, **kwargs)


    def test_inter_gene_max_space(self):
        inter_gene_max_space = (["T2SS", 32], ['Flagellum', 64])
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          inter_gene_max_space = inter_gene_max_space,
                          res_search_dir = '/tmp',
                          )
        self.assertEqual(self.cfg.inter_gene_max_space('T2SS'), 32)
        self.assertEqual(self.cfg.inter_gene_max_space('Flagellum'), 64)
        self.assertIsNone(self.cfg.inter_gene_max_space('Foo'))


    def test_min_genes_required(self):
        min_genes_required = (["T2SS", 32], ['Flagellum', 64])
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          min_genes_required = min_genes_required,
                          res_search_dir = '/tmp',
                          )
        self.assertEqual(self.cfg.min_genes_required('T2SS'), 32)
        self.assertEqual(self.cfg.min_genes_required('Flagellum'), 64)
        self.assertIsNone(self.cfg.min_genes_required('Foo'))

    def test_max_nb_genes(self):
        max_nb_genes = (["T2SS", 32], ['Flagellum', 64])
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          max_nb_genes = max_nb_genes,
                          res_search_dir = '/tmp',
                          )
        self.assertEqual(self.cfg.max_nb_genes('T2SS'), 32)
        self.assertEqual(self.cfg.max_nb_genes('Flagellum'), 64)
        self.assertIsNone(self.cfg.max_nb_genes('Foo'))


    def test_min_mandatory_genes_required(self):
        min_mandatory_genes_required = (["T2SS", 32], ['Flagellum', 64])
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          min_mandatory_genes_required = min_mandatory_genes_required,
                          res_search_dir = '/tmp',
                          )
        self.assertEqual(self.cfg.min_mandatory_genes_required('T2SS'), 32)
        self.assertEqual(self.cfg.min_mandatory_genes_required('Flagellum'), 64)
        self.assertIsNone(self.cfg.min_mandatory_genes_required('Foo'))
         
         
    def test_multi_loci(self):
       multi_loci = "T2SS,Flagellum"
       self.cfg = Config(cfg_file = "nimportnaoik",
                         sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                         db_type = 'gembase',
                         def_dir = os.path.join(self._data_dir, 'DEF'),
                         profile_dir = os.path.join(self._data_dir, 'profiles'),
                         multi_loci = multi_loci,
                         res_search_dir = '/tmp',
                         )
       self.assertTrue(self.cfg.multi_loci('T2SS'))
       self.assertTrue(self.cfg.multi_loci('Flagellum'))
       self.assertFalse(self.cfg.multi_loci('Foo'))
        
    def test_res_extract_suffix(self):
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = '/tmp',
                          )
        self.assertEqual(self.cfg.res_extract_suffix, '.res_hmm_extract')
        self.tearDown()
        res_extract_suffix = 'foo'
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_extract_suffix = res_extract_suffix,
                          res_search_dir = '/tmp',
                          )
        self.assertEqual(self.cfg.res_extract_suffix, res_extract_suffix)
         
         
    def test_res_search_dir(self):
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'res_search_dir' : 'foo',
        }
        self.assertRaises(ValueError, Config, **kwargs)
        res_search_dir = os.path.join(os.path.dirname(__file__), 'datatest')
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = res_search_dir
                          )
        self.assertEqual(self.cfg.res_search_dir , res_search_dir)
 
 
    def test_res_search_suffix(self):
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(os.path.dirname(__file__),'..', 'data',  'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = '/tmp',
                          )
        self.assertEqual(self.cfg.res_search_suffix, '.search_hmm.out')
        self.tearDown()
        res_search_suffix = 'foo'
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_suffix = res_search_suffix,
                          res_search_dir = '/tmp',
                          )
        self.assertEqual(self.cfg.res_search_suffix, res_search_suffix)
     
#    def test_save(self):
#        pass 
#      
    def test_sequence_db(self):
        kwargs = {'cfg_file' : "nimportnaoik",
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'worker_nb' : '2.3' ,
                  'res_search_dir' : '/tmp',
        }
        self.assertRaises(ValueError, Config, **kwargs)   
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : "foo",
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'worker_nb' : '2.3',
                  'res_search_dir' : '/tmp',
        }
        self.assertRaises(ValueError, Config, **kwargs) 
        sequence_db = os.path.join(self._data_dir, "base", "test_base.fa")
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = sequence_db,
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = '/tmp',
                          )  
        self.assertEqual(self.cfg.sequence_db, sequence_db)
 
 
    def test_worker_nb(self):
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = '/tmp'
                          )
        self.assertEqual(self.cfg.worker_nb, 1)
        self.tearDown()
        self.cfg = Config(cfg_file = "nimportnaoik",
                          sequence_db = os.path.join(self._data_dir, "base", "test_base.fa"),
                          db_type = 'gembase',
                          def_dir = os.path.join(self._data_dir, 'DEF'),
                          profile_dir = os.path.join(self._data_dir, 'profiles'),
                          res_search_dir = '/tmp',
                          worker_nb = 2
                          )
        self.assertEqual(self.cfg.worker_nb, 2)
        self.tearDown()
        kwargs = {'cfg_file' : "nimportnaoik",
                  'sequence_db' : os.path.join(self._data_dir, "base", "test_base.fa"),
                  'db_type' : 'gembase',
                  'def_dir' : os.path.join(self._data_dir, 'DEF'),
                  'profile_dir' : os.path.join(self._data_dir, 'profiles'),
                  'res_search_dir' : '/tmp',
                  'worker_nb' : '2.3'
        }
        self.assertRaises(ValueError, Config, **kwargs)