#########################################################################
# MacSyLib - Python library to detect macromolecular systems            #
#            in prokaryotes protein dataset using systems modelling     #
#            and similarity search.                                     #
#                                                                       #
# Authors: Sophie Abby, Bertrand Neron                                  #
# Copyright (c) 2014-2025  Institut Pasteur (Paris) and CNRS.           #
# See the COPYRIGHT file for details                                    #
#                                                                       #
# This file is part of MacSyLib package.                                #
#                                                                       #
# MacSyLib is free software: you can redistribute it and/or modify      #
# it under the terms of the GNU General Public License as published by  #
# the Free Software Foundation, either version 3 of the License, or     #
# (at your option) any later version.                                   #
#                                                                       #
# MacSyLib is distributed in the hope that it will be useful,           #
# but WITHOUT ANY WARRANTY; without even the implied warranty of        #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the          #
# GNU General Public License for more details .                         #
#                                                                       #
# You should have received a copy of the GNU General Public License     #
# along with MacSyLib (COPYING).                                        #
# If not, see <https://www.gnu.org/licenses/>.                          #
#########################################################################

import tempfile
import shutil
import os
import argparse
import sys
import tarfile
import unittest
import io
import shlex
from collections import namedtuple

try:
    import lxml
except ModuleNotFoundError:
    lxml = None
import yaml
import macsylib.registries
from macsylib.registries import scan_models_dir, ModelRegistry
from macsylib import model_package

from tests import MacsyTest
from macsylib.scripts import macsydata
from macsylib.error import MacsydataError, MacsyDataLimitError
import warnings
warnings.simplefilter('ignore', UserWarning,)
try:
    import git
except ModuleNotFoundError:
    git = None


class TestMacsydata(MacsyTest):

    def setUp(self):
        self._tmpdir = tempfile.TemporaryDirectory(prefix='test_msl_macsydata_')
        self.tmpdir = self._tmpdir.name
        self.models_dir = [os.path.join(self.tmpdir, 'models')]
        os.mkdir(self.models_dir[0])

        self.args = argparse.Namespace()
        self.args.org = 'foo'
        self.args.package_name = 'macsylib'
        self._remote_exists = macsydata.RemoteModelIndex.remote_exists
        macsydata.RemoteModelIndex.remote_exists = lambda x: True
        macsydata._log = macsydata.init_logger(20)  # 20 logging.INFO
        self.definition_1 = """<model inter_gene_max_space="20" min_mandatory_genes_required="1" min_genes_required="2" vers="2.1">
    <gene name="flgB" presence="mandatory"/>
    <gene name="flgC" presence="mandatory" inter_gene_max_space="2">
        <exchangeables>
            <gene name="abc" />
        </exchangeables>
    </gene>
</model>"""
        self.definition_2 = """<model inter_gene_max_space="20" min_mandatory_genes_required="1" min_genes_required="2" vers="2.1">
    <gene name="fliE" presence="mandatory" multi_system="true"/>
    <gene name="tadZ" presence="accessory" loner="true"/>
    <gene name="sctC" presence="forbidden"/>
</model>"""


    def tearDown(self):
        macsydata.RemoteModelIndex.remote_exists = self._remote_exists
        self._tmpdir.cleanup()
        # some function in macsydata script suppress the traceback
        # but without traceback it's hard to debug test :-(
        sys.tracebacklimit = 1000  # the default value

        # at each call of macsydata.main
        # init_logger is called and new handler is add
        # remove them
        logger = macsydata._log
        if logger:
            for handler in logger.handlers[:]:
                logger.removeHandler(handler)


    def create_fake_package(self, model,
                            definitions=True,
                            profiles=True,
                            gen_profiles=('flgB', 'flgC', 'fliE', 'tadZ', 'sctC', 'abc'),
                            metadata=True,
                            vers=True,
                            readme=True,
                            license=True,
                            dest='',
                            complex=False):
        pack_path = os.path.join(self.tmpdir, dest, model)
        os.makedirs(pack_path)
        if definitions:
            def_dir = os.path.join(pack_path, 'definitions')
            os.mkdir(def_dir)
            sub_fam_1 = os.path.join(def_dir, 'sub_fam_1')
            os.mkdir(sub_fam_1)
            sub_fam_2 = os.path.join(def_dir, 'sub_fam_2')
            os.mkdir(sub_fam_2)
            with open(os.path.join(sub_fam_1, "model_1.xml"), 'w') as f:
                f.write(self.definition_1)
            with open(os.path.join(sub_fam_2, "model_2.xml"), 'w') as f:
                f.write(self.definition_2)
            if complex:
                with open(os.path.join(sub_fam_1, "model_1_2.xml"), 'w') as f:
                    f.write(self.definition_1)
                with open(os.path.join(sub_fam_2, "model_2_2.xml"), 'w') as f:
                    f.write(self.definition_2)

        if profiles:
            profile_dir = os.path.join(pack_path, 'profiles')
            os.mkdir(profile_dir)
            for name in gen_profiles:
                shutil.copyfile(self.find_data('models', 'foo', 'profiles', f'{name}.hmm'),
                                os.path.join(profile_dir, f"{name}.hmm")
                                )
        if metadata:
            meta_path = self.find_data('pack_metadata', 'good_metadata.yml')
            meta_dest = os.path.join(pack_path, model_package.Metadata.name)
            with open(meta_path) as meta_file:
                meta = yaml.safe_load(meta_file)
            if not vers:
                meta['vers'] = None
            with open(meta_dest, 'w') as meta_file:
                yaml.dump(meta, meta_file, allow_unicode=True, indent=2)
        if readme:
            with open(os.path.join(pack_path, "README"), 'w') as f:
                f.write("# This a README\n")
        if license:
            with open(os.path.join(pack_path, "LICENSE"), 'w') as f:
                f.write("# This the License\n")
        return pack_path

    def _fake_download(self, pack_name, vers, dest=None):
        unarch_pack_path = self.create_fake_package(pack_name, dest='tmp')
        arch_path = f"{os.path.join(self.tmpdir, 'tmp', pack_name)}-{vers}.tar.gz"
        with tarfile.open(arch_path, "w:gz") as arch:
            arch.add(unarch_pack_path, arcname=pack_name)
        shutil.rmtree(unarch_pack_path)
        return arch_path

    def test_definition_bad_pack(self):
        pack_name = 'nimportnaoik'
        self.args.model = [pack_name]
        self.args.models_dir = None
        with self.catch_log(log_name='macsylib'):
            # macsylib.registry throw a warning if metadata is not found
            # silenced it
            with self.catch_log(log_name='macsydata') as log:
                with self.assertRaises(ValueError):
                    macsydata.do_show_definition(self.args)
                log_msg = log.get_value().strip()

        self.assertEqual(log_msg, f"Model Package '{pack_name}' not found.")

    def test_download(self):
        def fake_download(_, pack_name, vers, dest=None):
            path = os.path.join(self.tmpdir, f"{pack_name}-{vers}.tar.gz")
            os.mkdir(path)
            return path

        # The package requested exists download it
        remote_list_packages_vers = macsydata.RemoteModelIndex.list_package_vers
        macsydata.RemoteModelIndex.list_package_vers = lambda x, name: {'fake_1': ['1.0'],
                                                                        'fake_2': ['0.0b2']}[name]
        remote_download = macsydata.RemoteModelIndex.download
        macsydata.RemoteModelIndex.download = fake_download
        self.args.package = 'fake_1'
        self.args.dest = None
        try:
            with self.catch_log(log_name='macsydata') as log:
                macsydata.do_download(self.args)
                log_msg = log.get_value().strip()
        finally:
            macsydata.RemoteModelIndex.list_package_vers = remote_list_packages_vers
            macsydata.RemoteModelIndex.download = remote_download
        expected_msg = f"""Downloading {self.args.package} 1.0
Successfully downloaded models fake_1 in {os.path.join(self.tmpdir, 'fake_1-1.0.tar.gz')}"""
        self.assertEqual(log_msg, expected_msg)

        # The package requested does NOT exists
        remote_list_packages_vers = macsydata.RemoteModelIndex.list_package_vers
        macsydata.RemoteModelIndex.list_package_vers = lambda x, name: {'fake_1': ['1.0'],
                                                                        'fake_2': ['0.0b2']}[name]
        remote_download = macsydata.RemoteModelIndex.download
        macsydata.RemoteModelIndex.download = fake_download
        self.args.package = 'fake_1>2.0'
        self.args.dest = None
        try:
            with self.catch_log(log_name='macsydata') as log:
                macsydata.do_download(self.args)
                log_msg = log.get_value().strip()
        finally:
            macsydata.RemoteModelIndex.list_package_vers = remote_list_packages_vers
            macsydata.RemoteModelIndex.download = remote_download

        expected_msg = """No version that satisfy requirements '>2.0' for 'fake_1'.
Available versions: 1.0"""
        self.assertEqual(log_msg, expected_msg)

        # The package requested is NOT versioned
        remote_list_packages_vers = macsydata.RemoteModelIndex.list_package_vers
        macsydata.RemoteModelIndex.list_package_vers = lambda x, name: {'fake_1': [],
                                                                        'fake_2': ['0.0b2']}[name]
        remote_download = macsydata.RemoteModelIndex.download
        macsydata.RemoteModelIndex.download = fake_download
        self.args.package = 'fake_1>2.0'
        self.args.dest = None
        try:
            with self.catch_log(log_name='macsydata') as log:
                macsydata.do_download(self.args)
                log_msg = log.get_value().strip()
        finally:
            macsydata.RemoteModelIndex.list_package_vers = remote_list_packages_vers
            macsydata.RemoteModelIndex.download = remote_download

        self.assertEqual(log_msg, '')

        # Github has been requested over the limit
        def fake_download_limit(_, pack_name, vers, dest=None):
            raise MacsyDataLimitError('github limit error')

        remote_download = macsydata.RemoteModelIndex.download
        macsydata.RemoteModelIndex.download = fake_download_limit
        remote_list_packages_vers = macsydata.RemoteModelIndex.list_package_vers
        macsydata.RemoteModelIndex.list_package_vers = lambda x, name: {'fake_1': ['1.0'],
                                                                        'fake_2': ['0.0b2']}[name]
        self.args.package = 'fake_1'
        self.args.dest = None
        try:
            with self.catch_log(log_name='macsydata') as log:
                macsydata.do_download(self.args)
                log_msg = log.get_value().strip()
        finally:
            macsydata.RemoteModelIndex.list_package_vers = remote_list_packages_vers
            macsydata.RemoteModelIndex.download = remote_download
        expected_msg = "Downloading fake_1 1.0\ngithub limit error"
        self.assertEqual(log_msg, expected_msg)

    def test_install_remote_spec_not_found(self):
        model_pack_name = 'fake_pack'
        model_pack_vers = '0.0b2'
        macsydata_cache = os.path.join(self.tmpdir, 'cache')
        os.mkdir(macsydata_cache)
        macsydata_tmp = os.path.join(self.tmpdir, 'tmp')
        os.mkdir(macsydata_tmp)

        self.args.model_package = f"{model_pack_name}>{model_pack_vers}"
        self.args.cache = macsydata_cache
        self.args.user = False
        self.args.upgrade = False
        self.args.force = False
        self.args.org = 'macsy-foo-bar'  # to be sure that the network function are mocked
        self.args.target = None
        self.args.no_clean = False

        # functions which do net operations
        # so we need to mock them
        get_remote_available_versions = macsydata._get_remote_available_versions
        macsydata._get_remote_available_versions = lambda p_nam, org: [model_pack_vers]
        remote_exists = macsydata.RemoteModelIndex.remote_exists
        macsydata.RemoteModelIndex.remote_exists = lambda x: True
        remote_download = macsydata.RemoteModelIndex.download
        macsydata.RemoteModelIndex.download = self._fake_download
        macsydata.Config.models_dir = lambda x: self.models_dir
        try:
            with self.catch_log(log_name='macsydata') as log:
                macsydata.do_install(self.args)
                log_msg = log.get_value().strip()
            self.assertEqual(log_msg,
                             f"Could not find version that satisfied '{self.args.model_package}'")
        finally:
            del macsydata.Config.models_dir
            macsydata._get_remote_available_versions = get_remote_available_versions
            macsydata.RemoteModelIndex.remote_exists = remote_exists
            macsydata.RemoteModelIndex.download = remote_download

    def test_search_in_pack_name(self):
        self.args.pattern = 'Foo'
        self.args.org = 'macsy-foo-bar'  # to be sure that the network function are mocked
        self.args.careful = False
        self.args.match_case = False
        self.args.models_dir = None
        self.args.no_clean = False

        # functions which do net operations
        # so we need to mock them
        remote_exists = macsydata.RemoteModelIndex.remote_exists
        macsydata.RemoteModelIndex.remote_exists = lambda x: True
        remote_list_packages = macsydata.RemoteModelIndex.list_packages
        macsydata.RemoteModelIndex.list_packages = lambda x: ['FOO']
        remote_list_package_vers = macsydata.RemoteModelIndex.list_package_vers
        macsydata.RemoteModelIndex.list_package_vers = lambda x, pack_nam: ['0.1']
        remote_get_metadata = macsydata.RemoteModelIndex.get_metadata
        macsydata.RemoteModelIndex.get_metadata = lambda x, pac_nam: {'vers': '0.1',
                                                                      'short_desc': 'this is a foo desc_pattern'}
        try:
            with self.catch_io(out=True):
                macsydata.do_search(self.args)
                stdout = sys.stdout.getvalue().strip()
            self.assertEqual(stdout,  'FOO (0.1)                  - this is a foo desc_pattern')
        finally:
            macsydata.RemoteModelIndex.remote_exists = remote_exists
            macsydata.RemoteModelIndex.list_packages = remote_list_packages
            macsydata.RemoteModelIndex.get_metadata = remote_get_metadata
            macsydata.RemoteModelIndex.list_package_vers = remote_list_package_vers

        # case where package is not versioned
        self.args.pattern = 'Foo'
        self.args.org = 'macsy-foo-bar'  # to be sure that the network function are mocked
        self.args.careful = False
        self.args.match_case = False
        self.args.no_clean = False

        # functions which do net operations
        # so we need to mock them
        remote_exists = macsydata.RemoteModelIndex.remote_exists
        macsydata.RemoteModelIndex.remote_exists = lambda x: True
        remote_list_packages = macsydata.RemoteModelIndex.list_packages
        macsydata.RemoteModelIndex.list_packages = lambda x: ['FOO']
        remote_list_package_vers = macsydata.RemoteModelIndex.list_package_vers
        macsydata.RemoteModelIndex.list_package_vers = lambda x, pack_nam: []
        remote_get_metadata = macsydata.RemoteModelIndex.get_metadata
        macsydata.RemoteModelIndex.get_metadata = lambda x, pac_nam: {'short_desc': 'this is a foo desc_pattern'}
        try:
            with self.catch_io(out=True):
                macsydata.do_search(self.args)
                stdout = sys.stdout.getvalue().strip()
            self.assertEqual(stdout, '')
        finally:
            macsydata.RemoteModelIndex.remote_exists = remote_exists
            macsydata.RemoteModelIndex.list_packages = remote_list_packages
            macsydata.RemoteModelIndex.get_metadata = remote_get_metadata
            macsydata.RemoteModelIndex.list_package_vers = remote_list_package_vers


    def test_search_in_pack_name_match_case(self):
        self.args.pattern = 'Foo'.lower()
        self.args.org = 'macsy-foo-bar'  # to be sure that the network function are mocked
        self.args.careful = False
        self.args.match_case = True
        self.args.no_clean = False

        # functions which do net operations
        # so we need to mock them
        remote_exists = macsydata.RemoteModelIndex.remote_exists
        macsydata.RemoteModelIndex.remote_exists = lambda x: True
        remote_list_packages = macsydata.RemoteModelIndex.list_packages
        macsydata.RemoteModelIndex.list_packages = lambda x: ['FOO']
        remote_list_package_vers = macsydata.RemoteModelIndex.list_package_vers
        macsydata.RemoteModelIndex.list_package_vers = lambda x, pack_nam: ['0.1']
        remote_get_metadata = macsydata.RemoteModelIndex.get_metadata
        macsydata.RemoteModelIndex.get_metadata = lambda x, pac_nam: {'vers': '0.1',
                                                                      'short_desc': 'this is a foo desc_pattern'}
        try:
            with self.catch_io(out=True):
                macsydata.do_search(self.args)
                stdout = sys.stdout.getvalue().strip()
            self.assertEqual(stdout,  '')
        finally:
            macsydata.RemoteModelIndex.remote_exists = remote_exists
            macsydata.RemoteModelIndex.list_packages = remote_list_packages
            macsydata.RemoteModelIndex.get_metadata = remote_get_metadata
            macsydata.RemoteModelIndex.list_package_vers = remote_list_package_vers


    def test_search_in_pack_desc(self):
        self.args.pattern = 'sc_pat'
        self.args.org = 'macsy-foo-bar'  # to be sure that the network function are mocked
        self.args.careful = True
        self.args.match_case = False
        self.args.no_clean = False

        # functions which do net operations
        # so we need to mock them
        remote_exists = macsydata.RemoteModelIndex.remote_exists
        macsydata.RemoteModelIndex.remote_exists = lambda x: True
        remote_list_packages = macsydata.RemoteModelIndex.list_packages
        macsydata.RemoteModelIndex.list_packages = lambda x: ['FOO']
        remote_list_package_vers = macsydata.RemoteModelIndex.list_package_vers
        macsydata.RemoteModelIndex.list_package_vers = lambda x, pack_nam: ['0.1']
        remote_get_metadata = macsydata.RemoteModelIndex.get_metadata
        macsydata.RemoteModelIndex.get_metadata = lambda x, pac_nam: {'vers': '0.1',
                                                                      'short_desc': 'this is a foo desc_pattern'}
        try:
            with self.catch_io(out=True):
                macsydata.do_search(self.args)
                stdout = sys.stdout.getvalue().strip()
            self.assertEqual(stdout,  'FOO (0.1)                  - this is a foo desc_pattern')
        finally:
            macsydata.RemoteModelIndex.remote_exists = remote_exists
            macsydata.RemoteModelIndex.list_packages = remote_list_packages
            macsydata.RemoteModelIndex.get_metadata = remote_get_metadata
            macsydata.RemoteModelIndex.list_package_vers = remote_list_package_vers

        # test when package is not versioned
        self.args.pattern = 'sc_pat'
        self.args.org = 'macsy-foo-bar'  # to be sure that the network function are mocked
        self.args.careful = True
        self.args.match_case = False

        # functions which do net operations
        # so we need to mock them
        remote_exists = macsydata.RemoteModelIndex.remote_exists
        macsydata.RemoteModelIndex.remote_exists = lambda x: True
        remote_list_packages = macsydata.RemoteModelIndex.list_packages
        macsydata.RemoteModelIndex.list_packages = lambda x: ['FOO']
        remote_list_package_vers = macsydata.RemoteModelIndex.list_package_vers
        macsydata.RemoteModelIndex.list_package_vers = lambda x, pack_nam: []
        remote_get_metadata = macsydata.RemoteModelIndex.get_metadata
        macsydata.RemoteModelIndex.get_metadata = lambda x, pac_nam: {'short_desc': 'this is a foo desc_pattern'}
        try:
            with self.catch_io(out=True):
                macsydata.do_search(self.args)
                stdout = sys.stdout.getvalue().strip()
            self.assertEqual(stdout, '')
        finally:
            macsydata.RemoteModelIndex.remote_exists = remote_exists
            macsydata.RemoteModelIndex.list_packages = remote_list_packages
            macsydata.RemoteModelIndex.get_metadata = remote_get_metadata
            macsydata.RemoteModelIndex.list_package_vers = remote_list_package_vers


    def test_search_in_pack_desc_match_case(self):
        self.args.pattern = 'sc_pat'.upper()
        self.args.org = 'macsy-foo-bar'  # to be sure that the network function are mocked
        self.args.careful = True
        self.args.match_case = True
        self.args.no_clean = False

        # functions which do net operations
        # so we need to mock them
        remote_exists = macsydata.RemoteModelIndex.remote_exists
        macsydata.RemoteModelIndex.remote_exists = lambda x: True
        remote_list_packages = macsydata.RemoteModelIndex.list_packages
        macsydata.RemoteModelIndex.list_packages = lambda x: ['FOO']
        remote_list_package_vers = macsydata.RemoteModelIndex.list_package_vers
        macsydata.RemoteModelIndex.list_package_vers = lambda x, pack_nam: ['0.1']
        remote_get_metadata = macsydata.RemoteModelIndex.get_metadata
        macsydata.RemoteModelIndex.get_metadata = lambda x, pac_nam: {'vers': '0.1',
                                                                      'short_desc': 'this is a foo desc_pattern'}
        try:
            with self.catch_io(out=True):
                macsydata.do_search(self.args)
                stdout = sys.stdout.getvalue().strip()
            self.assertEqual(stdout,  '')
        finally:
            macsydata.RemoteModelIndex.remote_exists = remote_exists
            macsydata.RemoteModelIndex.list_packages = remote_list_packages
            macsydata.RemoteModelIndex.get_metadata = remote_get_metadata
            macsydata.RemoteModelIndex.list_package_vers = remote_list_package_vers


    def test_search_reach_limit(self):
        self.args.pattern = 'sc_pat'.upper()
        self.args.org = 'macsy-foo-bar'  # to be sure that the network function are mocked
        self.args.careful = True
        self.args.match_case = True
        self.args.no_clean = False

        # functions which do net operations
        # so we need to mock them
        def fake_remote(self):
            raise MacsyDataLimitError('bla')

        remote_exists = macsydata.RemoteModelIndex.remote_exists
        macsydata.RemoteModelIndex.remote_exists = fake_remote
        remote_list_packages = macsydata.RemoteModelIndex.list_packages
        macsydata.RemoteModelIndex.list_packages = lambda x: ['FOO']
        remote_list_package_vers = macsydata.RemoteModelIndex.list_package_vers
        macsydata.RemoteModelIndex.list_package_vers = lambda x, pack_nam: ['0.1']
        remote_get_metadata = macsydata.RemoteModelIndex.get_metadata
        macsydata.RemoteModelIndex.get_metadata = lambda x, pac_nam: {'vers': '0.1',
                                                                      'short_desc': 'this is a foo desc_pattern'}
        try:
            with self.catch_io(out=True):
                with self.catch_log(log_name='macsydata') as log:
                    macsydata.do_search(self.args)
                    log_msg = log.get_value().strip()
                stdout = sys.stdout.getvalue().strip()
            self.assertEqual(stdout,  '')
            self.assertEqual(log_msg, 'bla')
        finally:
            macsydata.RemoteModelIndex.remote_exists = remote_exists
            macsydata.RemoteModelIndex.list_packages = remote_list_packages
            macsydata.RemoteModelIndex.get_metadata = remote_get_metadata
            macsydata.RemoteModelIndex.list_package_vers = remote_list_package_vers


    @unittest.skipIf(git is None, "GitPython is not installed")
    def test_init_package_minimal(self):
        self.args.model_package = 'minimal_pack'
        self.args.maintainer = 'John Doe'
        self.args.email = 'john.doe@domain.org'
        self.args.authors = 'Jim Doe, John Doe'
        self.args.license = None
        self.args.holders = None
        self.args.desc = None
        self.args.models_dir = self.models_dir[0]
        self.args.no_clean = False
        # see below (test_init_package_complete)
        # why a do a mock for localtime
        fake_time = namedtuple('FakeTime', ['tm_year'])
        local_time_ori = macsydata.time.localtime
        macsydata.time.localtime = lambda: fake_time(2022)
        try:
            with self.catch_log(log_name='macsydata'):
                macsydata.do_init_package(self.args)

            files = ('README.md', 'metadata.yml', 'model_conf.xml', os.path.join('definitions', 'model_example.xml'))
            for f_name in files:
                with self.subTest(file_name=f_name):
                    expected_file = self.find_data(self.args.model_package, f_name)
                    got_file = os.path.join(self.args.models_dir, self.args.model_package, f_name)
                    self.assertFileEqual(expected_file, got_file)
        finally:
            macsydata.time.localtime = local_time_ori


    @unittest.skipIf(git is None, "GitPython is not installed")
    def test_init_package_license(self):
        self.args.model_package = 'init_pack_license'
        self.args.maintainer = 'John Doe'
        self.args.email = 'john.doe@domain.org'
        self.args.authors = 'Jim Doe, John Doe'
        self.args.license = 'cc-by-nc-sa'
        self.args.holders = None
        self.args.desc = 'description in one line of this package'
        self.args.models_dir = self.models_dir[0]
        self.args.no_clean = False
        # see below (test_init_package_complete)
        # why a do a mock for localtime
        fake_time = namedtuple('FakeTime', ['tm_year'])
        local_time_ori = macsydata.time.localtime
        macsydata.time.localtime = lambda: fake_time(2022)
        try:
            with self.catch_log(log_name='macsydata'):
                macsydata.do_init_package(self.args)

            files = ('README.md', 'metadata.yml', 'model_conf.xml', os.path.join('definitions', 'model_example.xml'))
            for f_name in files:
                with self.subTest(file_name=f_name):
                    expected_file = self.find_data(self.args.model_package, f_name)
                    got_file = os.path.join(self.args.models_dir, self.args.model_package, f_name)
                    self.assertFileEqual(expected_file, got_file)
        finally:
            macsydata.time.localtime = local_time_ori


    @unittest.skipIf(git is None, "GitPython is not installed")
    def test_init_package_complete(self):
        self.args.model_package = 'init_pack'
        self.args.maintainer = 'John Doe'
        self.args.email = 'john.doe@domain.org'
        self.args.authors = 'Jim Doe, John Doe'
        self.args.license = 'cc-by-nc-sa'
        self.args.holders = 'Pasteur'
        self.args.desc = 'description in one line of this package'
        self.args.models_dir = self.models_dir[0]
        self.args.no_clean = False
        # do_init_package call localtime to get year
        # and put it in copyright filed of metadata
        # so I do monkey patching to get reliable year
        # otherwise I have to adapt the test each new year ;-(
        fake_time = namedtuple('FakeTime', ['tm_year'])
        local_time_ori = macsydata.time.localtime
        macsydata.time.localtime = lambda: fake_time(2022)
        try:
            with self.catch_log(log_name='macsydata'):
                macsydata.do_init_package(self.args)

            files = ('README.md', 'metadata.yml', 'model_conf.xml', os.path.join('definitions', 'model_example.xml'))
            for f_name in files:
                with self.subTest(file_name=f_name):
                    expected_file = self.find_data(self.args.model_package, f_name)
                    got_file = os.path.join(self.args.models_dir, self.args.model_package, f_name)
                    self.assertFileEqual(expected_file, got_file)
        finally:
            macsydata.time.localtime = local_time_ori


    @unittest.skipIf(git is None, "GitPython is not installed")
    def test_init_empty_dir_exists(self):
        self.args.model_package = 'init_pack'
        self.args.maintainer = 'John Doe'
        self.args.email = 'john.doe@domain.org'
        self.args.authors = 'Jim Doe, John Doe'
        self.args.license = 'cc-by-nc-sa'
        self.args.holders = 'Pasteur'
        self.args.desc = 'description in one line of this package'
        self.args.models_dir = self.models_dir[0]
        self.args.no_clean = False
        # see above (test_init_package_complete)
        # why a do a mock for localtime
        fake_time = namedtuple('FakeTime', ['tm_year'])
        local_time_ori = macsydata.time.localtime
        macsydata.time.localtime = lambda: fake_time(2022)
        os.makedirs(os.path.join(self.models_dir[0], self.args.model_package))
        try:
            with self.catch_log(log_name='macsydata'):
                macsydata.do_init_package(self.args)

            files = ('README.md', 'metadata.yml', 'model_conf.xml', os.path.join('definitions', 'model_example.xml'))
            for f_name in files:
                with self.subTest(file_name=f_name):
                    expected_file = self.find_data(self.args.model_package, f_name)
                    got_file = os.path.join(self.args.models_dir, self.args.model_package, f_name)
                    self.assertFileEqual(expected_file, got_file)
        finally:
            macsydata.time.localtime = local_time_ori


    @unittest.skipIf(git is None, "GitPython is not installed")
    def test_init_dir_exists_not_pack(self):
        self.args.model_package = 'init_pack'
        self.args.maintainer = 'John Doe'
        self.args.email = 'john.doe@domain.org'
        self.args.authors = 'Jim Doe, John Doe'
        self.args.license = 'cc-by-nc-sa'
        self.args.holders = 'Pasteur'
        self.args.desc = 'description in one line of this package'
        self.args.models_dir = self.models_dir[0]
        self.args.no_clean = False
        # see above (test_init_package_complete)
        # why a do a mock for localtime
        fake_time = namedtuple('FakeTime', ['tm_year'])
        local_time_ori = macsydata.time.localtime
        macsydata.time.localtime = lambda: fake_time(2022)
        pack_path = os.path.join(self.models_dir[0], self.args.model_package)
        os.makedirs(pack_path)
        os.mkdir(os.path.join(pack_path, 'nimportnaoik'))
        try:
            with self.catch_log(log_name='macsydata') as log:
                with self.assertRaises(ValueError):
                    macsydata.do_init_package(self.args)
                log_msg = log.get_value().strip()
            self.assertEqual(log_msg,
                             f"{pack_path} already exits and not look a model package:"
                             f" There is no definitions, profiles.")

        finally:
            macsydata.time.localtime = local_time_ori

    @unittest.skipIf(git is None, "GitPython is not installed")
    def test_init_dir_exists_look_pack(self):
        self.args.model_package = 'init_pack'
        self.args.maintainer = 'John Doe'
        self.args.email = 'john.doe@domain.org'
        self.args.authors = 'Jim Doe, John Doe'
        self.args.license = 'cc-by-nc-sa'
        self.args.holders = 'Pasteur'
        self.args.desc = 'description in one line of this package'
        self.args.models_dir = self.models_dir[0]
        self.args.no_clean = False
        # see above (test_init_package_complete)
        # why a do a mock for localtime
        fake_time = namedtuple('FakeTime', ['tm_year'])
        local_time_ori = macsydata.time.localtime
        macsydata.time.localtime = lambda: fake_time(2022)
        pack_path = os.path.join(self.models_dir[0], self.args.model_package)
        os.makedirs(pack_path)
        os.mkdir(os.path.join(pack_path, 'definitions'))
        os.mkdir(os.path.join(pack_path, 'profiles'))
        git.Repo.init(pack_path)
        try:
            with self.catch_log(log_name='macsydata'):
                macsydata.do_init_package(self.args)
            files = ('README.md', 'metadata.yml', 'model_conf.xml', os.path.join('definitions', 'model_example.xml'))
            for f_name in files:
                with self.subTest(file_name=f_name):
                    expected_file = self.find_data(self.args.model_package, f_name)
                    got_file = os.path.join(self.args.models_dir, self.args.model_package, f_name)
                    self.assertFileEqual(expected_file, got_file)
            repo = git.Repo(pack_path)
            tree = repo.head.commit.tree
            files_and_dirs = {entry.name for entry in tree}
            # profiles is empty so not in git
            # we list only first level so 'definitions/model_example.xml' does not appear
            self.assertEqual({'COPYRIGHT', 'LICENSE', 'README.md', 'definitions', 'metadata.yml', 'model_conf.xml'},
                             files_and_dirs)
        finally:
            macsydata.time.localtime = local_time_ori


    @unittest.skipIf(git is None, "GitPython is not installed")
    def test_init_existing_pack(self):
        self.args.model_package = 'init_pack'
        self.args.maintainer = 'John Doe'
        self.args.email = 'john.doe@domain.org'
        self.args.authors = 'Jim Doe, John Doe'
        self.args.license = 'cc-by-nc-sa'
        self.args.holders = 'Pasteur'
        self.args.desc = 'description in one line of this package'
        self.args.models_dir = self.models_dir[0]
        self.args.no_clean = False
        # see above (test_init_package_complete)
        # why a do a mock for localtime
        fake_time = namedtuple('FakeTime', ['tm_year'])
        local_time_ori = macsydata.time.localtime
        macsydata.time.localtime = lambda: fake_time(2022)
        pack_path = os.path.join(self.models_dir[0], self.args.model_package)
        with self.catch_log(log_name='macsydata'):
            macsydata.do_init_package(self.args)
        try:
            with self.catch_log(log_name='macsydata'):
                macsydata.do_init_package(self.args)
            files = ('README.md', 'metadata.yml', 'model_conf.xml', os.path.join('definitions', 'model_example.xml'))
            for f_name in files:
                with self.subTest(file_name=f_name):
                    expected_file = self.find_data(self.args.model_package, f_name)
                    got_file = os.path.join(self.args.models_dir, self.args.model_package, f_name)
                    self.assertFileEqual(expected_file, got_file)
            repo = git.Repo(pack_path)
            tree = repo.head.commit.tree
            files_and_dirs = {entry.name for entry in tree}
            # profiles is empty so not in git
            # we list only first level so 'definitions/model_example.xml' does not appear
            self.assertEqual({'COPYRIGHT', 'LICENSE', 'README.md', 'definitions', 'metadata.yml', 'model_conf.xml'},
                             files_and_dirs)
        finally:
            macsydata.time.localtime = local_time_ori


    @unittest.skipIf(git is None, "GitPython is not installed")
    def test_init_existing_file(self):
        self.args.model_package = 'init_pack'
        self.args.maintainer = 'John Doe'
        self.args.email = 'john.doe@domain.org'
        self.args.authors = 'Jim Doe, John Doe'
        self.args.license = 'cc-by-nc-sa'
        self.args.holders = 'Pasteur'
        self.args.desc = 'description in one line of this package'
        self.args.models_dir = self.models_dir[0]
        self.args.no_clean = False
        # see above (test_init_package_complete)
        # why a do a mock for localtime
        fake_time = namedtuple('FakeTime', ['tm_year'])
        local_time_ori = macsydata.time.localtime
        macsydata.time.localtime = lambda: fake_time(2022)
        pack_path = os.path.join(self.models_dir[0], self.args.model_package)
        open(pack_path, 'w').close()
        try:
            with self.catch_log(log_name='macsydata') as log:
                with self.assertRaises(ValueError):
                    macsydata.do_init_package(self.args)
                log_msg = log.get_value().strip()
                self.assertEqual(log_msg,
                                 f"{pack_path} already exists and is not a directory.")
        finally:
            macsydata.time.localtime = local_time_ori


    def test_init_no_git(self):
        ori_imp = __import__

        def fake_import(name, *args):
            if name =='git':
                raise ModuleNotFoundError()
            return ori_imp(name, *args)

        globals()['__builtins__']['__import__'] = fake_import

        real_exit = sys.exit
        macsydata.sys.exit = self.fake_exit

        self.args.model_package = 'minimal_pack'
        self.args.maintainer = 'John Doe'
        self.args.email = 'john.doe@domain.org'
        self.args.authors = 'Jim Doe, John Doe'
        self.args.license = None
        self.args.holders = None
        self.args.desc = None
        self.args.models_dir = self.models_dir[0]
        self.args.no_clean = False
        self.args.tool_name = 'msl_data'

        try:
            with self.catch_log(log_name='macsydata') as log:
                with self.assertRaises(TypeError):
                    macsydata.do_init_package(self.args)
                log_msg = log.get_value().strip()
        finally:
            globals()['__builtins__']['__import__'] = ori_imp
            macsydata.sys.exit = real_exit

        expected_log = """GitPython is not installed, `msl_data init` is disabled.
To turn this feature ON:
  - install git
  - then run `python -m pip install macsylib[model]` in your activated environment."""
        self.maxDiff = None
        self.assertEqual(log_msg, expected_log)


    def test_build_argparser(self):
        tool_name = 'msl_data'
        cmd = f"{tool_name} install toto>1"
        version = f"{tool_name} version message"
        parser = macsydata.build_arg_parser(macsydata._cmde_line_header(), version)
        args = parser.parse_args(cmd.split()[1:])
        self.assertEqual(args.func.__name__, 'do_install')
        self.assertEqual(args.model_package, 'toto>1')
        self.assertEqual(args.org, 'macsy-models')
        self.assertFalse(args.force)
        self.assertFalse(args.upgrade)
        self.assertFalse(args.user)

        cmd = f"{tool_name} install --org foo --user --force toto>1"
        args = parser.parse_args(cmd.split()[1:])
        self.assertEqual(args.func.__name__, 'do_install')
        self.assertEqual(args.model_package, 'toto>1')
        self.assertEqual(args.org, 'foo')
        self.assertTrue(args.force)
        self.assertFalse(args.upgrade)
        self.assertTrue(args.user)

        cmd = f"{tool_name} uninstall toto"
        args = parser.parse_args(cmd.split()[1:])
        self.assertEqual(args.func.__name__, 'do_uninstall')
        self.assertEqual(args.model_package, 'toto')

        cmd = f"{tool_name} search TXSS"
        args = parser.parse_args(cmd.split()[1:])
        self.assertEqual(args.func.__name__, 'do_search')
        self.assertEqual(args.pattern, 'TXSS')
        self.assertEqual(args.org, 'macsy-models')
        self.assertFalse(args.careful)
        self.assertFalse(args.match_case)

        cmd = f"{tool_name} search -S --match-case TXSS"
        args = parser.parse_args(cmd.split()[1:])
        self.assertEqual(args.func.__name__, 'do_search')
        self.assertEqual(args.pattern, 'TXSS')
        self.assertEqual(args.org, 'macsy-models')
        self.assertTrue(args.careful)
        self.assertTrue(args.match_case)

        cmd = f"{tool_name} download foo"
        args = parser.parse_args(cmd.split()[1:])
        self.assertEqual(args.func.__name__, 'do_download')
        self.assertEqual(args.model_package, 'foo')
        self.assertEqual(args.dest, os.getcwd())
        self.assertEqual(args.org, 'macsy-models')

        cmd = f"{tool_name} available"
        args = parser.parse_args(cmd.split()[1:])
        self.assertEqual(args.func.__name__, 'do_available')

        if git is not None:
            cmd = f"{tool_name} init --model-package foo --authors 'john Doe' --maintainer 'Jim Doe' " \
                  "--email 'jim.doe@my_domain.com'"
            args = parser.parse_args(shlex.split(cmd)[1:])
            self.assertEqual(args.func.__name__, 'do_init_package')
            self.assertEqual(args.model_package, 'foo')
            self.assertEqual(args.authors, 'john Doe')
            self.assertEqual(args.maintainer, 'Jim Doe')
            self.assertEqual(args.email, 'jim.doe@my_domain.com')

    def test_cmd_name(self):
        version = "msl version message"
        parser = macsydata.build_arg_parser(macsydata._cmde_line_header(), version)
        cmd = "msl_data download foo"
        args = parser.parse_args(cmd.split()[1:])
        cmd_name = macsydata.cmd_name(args)
        self.assertEqual(cmd_name, 'msl_data download')

    def test_verbosity_to_log_level(self):
        level = macsydata.verbosity_to_log_level(1)
        self.assertEqual(level, 10)
        level = macsydata.verbosity_to_log_level(5)
        self.assertEqual(level, 1)

    def test_no_subcommand(self):
        cmd = "msl_data"
        parser = macsydata.build_arg_parser(macsydata._cmde_line_header(),
                                            'msl_data version message',
                                            package_name='macsylib',
                                            tool_name='msl_data',
                                            color=False)
        out = io.StringIO()
        parser.print_help(file=out)

        with self.catch_io(out=True):
            macsydata.main(args=cmd.split()[1:])
            stdout = sys.stdout.getvalue().strip()
        self.assertEqual(stdout,
                         out.getvalue().strip())