import os.path as osp

import shutil

from unittest.mock import patch

from cubicweb import ExecutionError

from cubicweb.devtools import testlib, ApptestConfiguration

from cubicweb.server.serverctl import (

    DBDumpCommand,

    RepositorySchedulerCommand,

    SynchronizeSourceCommand,

)

from cubicweb.server.serverconfig import ServerConfiguration

class ServerCTLTC(testlib.CubicWebTC):

    def setUp(self):

        super(ServerCTLTC, self).setUp()

        self.orig_config_for = ServerConfiguration.config_for

        def config_for(appid):

            return ApptestConfiguration(appid, __file__)

        ServerConfiguration.config_for = staticmethod(config_for)

    def tearDown(self):

        ServerConfiguration.config_for = self.orig_config_for

        super(ServerCTLTC, self).tearDown()

    def test_dump(self):

        DBDumpCommand(None).run([self.appid])

        shutil.rmtree(osp.join(self.config.apphome, 'backup'))

    def test_scheduler(self):

        cmd = RepositorySchedulerCommand(None)

        with patch('sched.scheduler.run',

                   side_effect=RuntimeError('boom')) as patched_run:

            with self.assertRaises(RuntimeError) as exc_cm:

                with self.assertLogs('cubicweb.repository', level='INFO') as log_cm:

                    cmd.run([self.appid])

        # make sure repository scheduler started

        scheduler_start_message = (

            'INFO:cubicweb.repository:starting repository scheduler with '

            'tasks: update_feeds, expire_dataimports'

        )

        self.assertIn(scheduler_start_message, log_cm.output)

        # and that scheduler's run method got called

        self.assertIn('boom', str(exc_cm.exception))

        patched_run.assert_called_once_with()

        # make sure repository's shutdown method got called

        repo_shutdown_message = 'INFO:cubicweb.repository:shutting down repository'

        self.assertIn(repo_shutdown_message, log_cm.output)

    def test_source_sync(self):

        with self.admin_access.repo_cnx() as cnx:

            cnx.create_entity('CWSource', name=u'success_feed', type=u'datafeed',

                              parser=u'test_source_parser_success',

                              url=u'ignored')

            cnx.create_entity('CWSource', name=u'fail_feed', type=u'datafeed',

                              parser=u'test_source_parser_fail',

                              url=u'ignored')

            cnx.commit()

            cmd = SynchronizeSourceCommand(None)

            cmd.config.force = 1

            # Should sync all sources even if one failed

            with self.assertRaises(ExecutionError) as exc:

                cmd.run([self.appid])

            self.assertEqual(len(cnx.find('Card', title=u'success')), 1)

            self.assertEqual(len(cnx.find('Card', title=u'fail')), 0)

            self.assertEqual(str(exc.exception), 'All sources where not synced')

            # call with named sources

            cmd.run([self.appid, u'success_feed'])

            self.assertEqual(len(cnx.find('Card', title=u'success')), 2)

            with self.assertRaises(ExecutionError) as exc:

                cmd.run([self.appid, u'fail_feed'])

            self.assertEqual(str(exc.exception), 'All sources where not synced')

            self.assertEqual(len(cnx.find('Card', title=u'fail')), 0)

if __name__ == '__main__':

    from unittest import main

    main()