# -*- coding: utf-8 -*-

# Copyright (C) 2012-2018 Red Hat, Inc.

#

# This copyrighted material is made available to anyone wishing to use,

# modify, copy, or redistribute it subject to the terms and conditions of

# the GNU General Public License v.2, or (at your option) any later version.

# This program is distributed in the hope that it will be useful, but WITHOUT

# ANY WARRANTY expressed or implied, including the implied warranties 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 this program; if not, write to the

# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.  Any Red Hat trademarks that are incorporated in the

# source code or documentation are not subject to the GNU General Public

# License and may only be used or replicated with the express permission of

# Red Hat, Inc.

#

from __future__ import absolute_import

from __future__ import unicode_literals

import libdnf.transaction

import dnf.cli.output

import dnf.const

import dnf.transaction

import tests.support

from tests.support import mock

INFOOUTPUT_OUTPUT = """\

Name         : tour

Epoch        : 1

Version      : 5

Release      : 0

Architecture : noarch

Size         : 0.0  

Source       : tour.src.rpm

Repository   : None

Summary      : A summary of the package.

URL          : http://example.com

License      : GPL+

Description  : 

"""

LIST_TRANSACTION_OUTPUT = u"""\

================================================================================

 Package           Arch              Version           Repository          Size

================================================================================

Upgrading:

 pepper            x86_64            20-1              updates              0  

     replacing  hole.x86_64 1-1

Transaction Summary

================================================================================

Upgrade  1 Package

"""

class OutputFunctionsTest(tests.support.TestCase):

    def test_make_lists(self):

        return

        goal = mock.Mock(get_reason=lambda x: libdnf.transaction.TransactionItemReason_USER)

        ts = dnf.transaction.Transaction()

#        ts = dnf.db.history.

        ts.add_install('pepper-3', [])

        ts.add_install('pepper-2', [])

        lists = dnf.cli.output._make_lists(ts, goal)

        self.assertEmpty(lists.erased)

        self.assertEqual([tsi._active for tsi in lists.installed],

                         ['pepper-2', 'pepper-3'])

    def test_spread(self):

        fun = dnf.cli.output._spread_in_columns

        self.assertEqual(fun(3, "tour", list(range(3))),

                         [('tour', 0, 1), ('', 2, '')])

        self.assertEqual(fun(3, "tour", ()), [('tour', '', '')])

        self.assertEqual(fun(5, "tour", list(range(8))),

                         [('tour', 0, 1, 2, 3), ('', 4, 5, 6, 7)])

class OutputTest(tests.support.DnfBaseTestCase):

    REPOS = ['updates']

    @staticmethod

    def _keyboard_interrupt(*ignored):

        raise KeyboardInterrupt

    @staticmethod

    def _eof_error(*ignored):

        raise EOFError

    def setUp(self):

        super(OutputTest, self).setUp()

        self.output = dnf.cli.output.Output(self.base, self.base.conf)

    @mock.patch('dnf.cli.term._real_term_width', return_value=80)

    def test_col_widths(self, _real_term_width):

        rows = (('pep', 'per', 'row',

                 '', 'lon', 'e'))

        self.assertCountEqual(self.output._col_widths(rows), (-38, -37, -1))

    @mock.patch('dnf.cli.output._', dnf.pycomp.NullTranslations().ugettext)

    @mock.patch('dnf.cli.output.P_', dnf.pycomp.NullTranslations().ungettext)

    @mock.patch('dnf.cli.term._real_term_width', return_value=80)

    def test_list_transaction(self, _real_term_width):

        return

        sack = self.base.sack

        q = sack.query().filter(name='pepper')

        i = q.installed()[0]

        u = q.available()[0]

        obs = sack.query().filter(name='hole').installed()[0]

        transaction = dnf.transaction.Transaction()

        transaction.add_upgrade(u, i, [obs])

        self.assertEqual(self.output.list_transaction(transaction),

                         LIST_TRANSACTION_OUTPUT)

    @mock.patch('dnf.cli.output._', dnf.pycomp.NullTranslations().ugettext)

    @mock.patch('dnf.i18n.ucd_input')

    def test_userconfirm(self, input_fnc):

        # with defaultyes==False

        input_fnc.return_value = 'y'

        self.assertTrue(self.output.userconfirm())

        self.assertEqual(input_fnc.call_args, mock.call(u'Is this ok [y/N]: '))

        input_fnc.return_value = 'n'

        self.assertFalse(self.output.userconfirm())

        input_fnc.return_value = ''

        self.assertFalse(self.output.userconfirm())

        input_fnc.side_effect = self._keyboard_interrupt

        input_fnc.return_value = 'y'

        self.assertFalse(self.output.userconfirm())

        input_fnc.side_effect = self._eof_error

        self.assertFalse(self.output.userconfirm())

        # with defaultyes==True

        self.output.conf.defaultyes = True

        input_fnc.side_effect = None

        input_fnc.return_value = ''

        self.assertTrue(self.output.userconfirm())

        input_fnc.side_effect = self._keyboard_interrupt

        input_fnc.return_value = ''

        self.assertFalse(self.output.userconfirm())

        input_fnc.side_effect = self._eof_error

        self.assertTrue(self.output.userconfirm())

    def _to_unicode_mock(str):

        return {'y': 'a', 'yes': 'ano', 'n': 'e', 'no': 'ee'}.get(str, str)

    @mock.patch('dnf.cli.output._', _to_unicode_mock)

    @mock.patch('dnf.i18n.ucd_input')

    def test_userconfirm_translated(self, input_fnc):

        input_fnc.return_value = 'ee'

        self.assertFalse(self.output.userconfirm())

        input_fnc.return_value = 'ano'

        self.assertTrue(self.output.userconfirm())

    class _InputGenerator(object):

        INPUT = ['haha', 'dada', 'n']

        def __init__(self):

            self.called = 0

        def __call__(self, msg):

            ret = self.INPUT[self.called]

            self.called += 1

            return ret

    def test_userconfirm_bad_input(self):

        input_fnc = self._InputGenerator()

        with mock.patch('dnf.i18n.ucd_input', input_fnc):

            self.assertFalse(self.output.userconfirm())

        self.assertEqual(input_fnc.called, 3)

    @mock.patch('dnf.cli.output._', dnf.pycomp.NullTranslations().ugettext)

    @mock.patch('dnf.cli.term._real_term_width', return_value=80)

    def test_infoOutput_with_none_description(self, _real_term_width):

        pkg = tests.support.MockPackage('tour-5-0.noarch')

        pkg._from_system = False

        pkg._size = 0

        pkg._pkgid = None

        pkg.repoid = None

        pkg.e = pkg.epoch = 1

        pkg.v = pkg.version

        pkg.r = pkg.release

        pkg.sourcerpm = 'tour.src.rpm'

        pkg.summary = 'A summary of the package.'

        pkg.url = 'http://example.com'

        pkg.license = 'GPL+'

        pkg.description = None

        with mock.patch('sys.stdout') as stdout:

            print(self.output.infoOutput(pkg))

        written = ''.join([mc[1][0] for mc in stdout.method_calls

                          if mc[0] == 'write'])

        self.assertEqual(written, INFOOUTPUT_OUTPUT)

PKGS_IN_GROUPS_OUTPUT = u"""\

Group: Pepper's

 Mandatory Packages:

   hole

   lotus

"""

PKGS_IN_GROUPS_VERBOSE_OUTPUT = u"""\

Group: Pepper's

 Group-Id: Peppers

 Mandatory Packages:

   hole-1-1.x86_64                                                       @System

   lotus-3-16.i686                                                       main   

"""

GROUPS_IN_ENVIRONMENT_OUTPUT = """\

Environment Group: Sugar Desktop Environment

 Description: A software playground for learning about learning.

 Mandatory Groups:

   Pepper's

   Solid Ground

 Optional Groups:

   Base

"""

class GroupOutputTest(tests.support.DnfBaseTestCase):

    REPOS = ['main']

    COMPS = True

    def setUp(self):

        super(GroupOutputTest, self).setUp()

        self.output = dnf.cli.output.Output(self.base, self.base.conf)

    @mock.patch('dnf.cli.output._', dnf.pycomp.NullTranslations().ugettext)

    @mock.patch('dnf.cli.term._real_term_width', return_value=80)

    def test_group_info(self, _real_term_width):

        group = self.base.comps.group_by_pattern('Peppers')

        with tests.support.patch_std_streams() as (stdout, stderr):

            self.output.display_pkgs_in_groups(group)

        self.assertEqual(stdout.getvalue(), PKGS_IN_GROUPS_OUTPUT)

    @mock.patch('dnf.cli.output._', dnf.pycomp.NullTranslations().ugettext)

    @mock.patch('dnf.cli.term._real_term_width', return_value=80)

    def test_group_verbose_info(self, _real_term_width):

        group = self.base.comps.group_by_pattern('Peppers')

        self.base.set_debuglevel(dnf.const.VERBOSE_LEVEL)

        with tests.support.patch_std_streams() as (stdout, stderr):

            self.output.display_pkgs_in_groups(group)

        self.assertEqual(stdout.getvalue(), PKGS_IN_GROUPS_VERBOSE_OUTPUT)

    @mock.patch('dnf.cli.output._', dnf.pycomp.NullTranslations().ugettext)

    @mock.patch('dnf.cli.term._real_term_width', return_value=80)

    def test_environment_info(self, _real_term_width):

        env = self.base.comps.environments[0]

        with tests.support.patch_std_streams() as (stdout, stderr):

            self.output.display_groups_in_environment(env)

        self.assertEqual(stdout.getvalue(), GROUPS_IN_ENVIRONMENT_OUTPUT)