import os
import logging
import tempfile

from packaging import logger
from packaging.dist import Distribution
from packaging.tests import support, unittest



def run_test(tester, test):
    tester.setUp()
    try:
        getattr(tester, test)()
    finally:
        tester.tearDown()


class TestingSupportTestCase(unittest.TestCase):

    def test_fake_dec(self):
        @support.fake_dec(1, 2, k=3)
        def func(arg0, *args, **kargs):
            return arg0, args, kargs
        self.assertEqual(func(-1, -2, k= -3), (-1, (-2,), {'k':-3}))

    def test_TempdirManager(self):
        files = {}

        class Tester(support.TempdirManager, unittest.TestCase):

            def runTest(self2):
                # This method is needed for back portability
                pass

            def test_mktempfile(self2):
                tmpfile = self2.mktempfile()
                files['test_mktempfile'] = tmpfile.name
                self.assertTrue(os.path.isfile(tmpfile.name))

            def test_mkdtemp(self2):
                tmpdir = self2.mkdtemp()
                files['test_mkdtemp'] = tmpdir
                self.assertTrue(os.path.isdir(tmpdir))

            def test_write_file(self2):
                tmpdir = self2.mkdtemp()
                files['test_write_file'] = tmpdir
                self2.write_file((tmpdir, 'file1'), 'me file 1')
                file1 = os.path.join(tmpdir, 'file1')
                self.assertTrue(os.path.isfile(file1))
                text = ''
                with open(file1, 'r') as f:
                    text = f.read()
                self.assertEqual(text, 'me file 1')

            def test_create_dist(self2):
                project_dir, dist = self2.create_dist()
                files['test_create_dist'] = project_dir
                self.assertTrue(os.path.isdir(project_dir))
                self.assertIsInstance(dist, Distribution)

            def test_assertIsFile(self2):
                fd, fn = tempfile.mkstemp()
                os.close(fd)
                self.addCleanup(support.unlink, fn)
                self2.assertIsFile(fn)
                self.assertRaises(AssertionError, self2.assertIsFile, 'foO')

            def test_assertIsNotFile(self2):
                tmpdir = self2.mkdtemp()
                self2.assertIsNotFile(tmpdir)

        tester = Tester()
        for name in ('test_mktempfile', 'test_mkdtemp', 'test_write_file',
                     'test_create_dist', 'test_assertIsFile',
                     'test_assertIsNotFile'):

            run_test(tester, name)

            # check clean-up
            if name in files:
                self.assertFalse(os.path.exists(files[name]))

    def test_EnvironRestorer(self):

        # Take the some existing environment key
        envlst = list(os.environ)
        firstEnv = None
        if envlst:
            firstEnv = envlst[0]

        class Tester(support.EnvironRestorer, unittest.TestCase):

            # Keys to restore
            restore_environ = ['NO_KEY_42']
            if firstEnv:
               restore_environ.append(firstEnv)

            # Manipulate the keys here
            def runTest(self2):
                os.environ['NO_KEY_42'] = '42'
                if firstEnv:
                    os.environ[firstEnv] = 'test_EnvironRestorer'

        # make book keeping and run tester
        if firstEnv:
            saved_pythonpath = os.environ[firstEnv]
        tester = Tester()
        run_test(tester, 'runTest')

        # check the environment for changes
        self.assert_('NO_KEY_42' not in os.environ)
        if firstEnv:
            self.assertEqual(saved_pythonpath, os.environ[firstEnv])


    def test_LoggingCatcher(self):

        class Tester(support.LoggingCatcher, unittest.TestCase):

            def runTest(self2):
                self.assertFalse(self2.loghandler.shouldFlush())
                logger.debug('debug_msg')
                logger.info('info_msg')
                logger.warn('warn_msg')
                logger.error('error_msg')
                logger.critical('critical_msg')

                # Lowest level is DEBUG
                self.assertEqual(
                    self2.get_logs(level=logging.DEBUG, flush=False),
                    ['debug_msg'])

                # Default is WARNING
                self.assertEqual(self2.get_logs(flush=False), ['warn_msg'])

                # The other levels
                self.assertEqual(
                    self2.get_logs(level=logging.INFO, flush=False),
                    ['info_msg'])
                self.assertEqual(
                    self2.get_logs(level=logging.ERROR, flush=False),
                    ['error_msg'])
                self.assertEqual(
                    self2.get_logs(level=logging.CRITICAL, flush=False),
                    ['critical_msg'])

                # check flush (from longhandler and get_logs)
                self2.loghandler.flush()
                logger.warn('warn_message_2')
                logger.info('info_message_2')
                self.assertEqual(self2.get_logs(), ['warn_message_2'])
                self.assertEqual(self2.get_logs(level=logging.INFO), [])

        tester = Tester()
        run_test(tester, 'runTest')

    def test_DummyCommand(self):
        cmd = support.DummyCommand(attrFoo='Foo', attr42=42)
        cmd.ensure_finalized()
        self.assertEqual(cmd.attrFoo, 'Foo')
        self.assertEqual(cmd.attr42, 42)


def test_suite():
    return unittest.makeSuite(TestingSupportTestCase)

if __name__ == "__main__":
    unittest.main(defaultTest="test_suite")