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

# Copyright (C) 2013-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.

#

"""Tests of the history undo command."""

from __future__ import absolute_import

from __future__ import unicode_literals

import libdnf.transaction

from dnf.exceptions import PackagesNotAvailableError, PackagesNotInstalledError

#from dnf.history import NEVRAOperations

#from dnf.transaction import ERASE, DOWNGRADE, INSTALL, REINSTALL, UPGRADE

#from dnf.transaction import TransactionItem

import tests.support

'''

class BaseTest(tests.support.DnfBaseTestCase):

    """Unit tests of dnf.Base."""

    REPOS = ['main', 'updates']

    def assertEqualTransactionItems(self, one, two):

        self.assertEqual(one.op_type, two.op_type)

        self.assertEqual(str(one.installed), str(two.installed))

        self.assertEqual(str(one.erased), str(two.erased))

        self.assertEqual([str(i) for i in one.obsoleted], [str(i) for i in two.obsoleted])

        self.assertEqual(one.reason, two.reason)

    def test_history_undo_operations_downgrade(self):

        """Test history_undo_operations with a downgrade."""

        operations = NEVRAOperations()

        operations.add(

            'Downgrade',

            'pepper-20-0.x86_64',

            'pepper-20-1.x86_64',

            ('lotus-3-16.x86_64',)

        )

        with self.base:

            self.base._history_undo_operations(operations, 0)

            transaction_it = iter(self.base.transaction)

            actual = next(transaction_it)

            expected = TransactionItem(

                UPGRADE,

                installed='pepper-20-1.x86_64',

                erased='pepper-20-0.x86_64'

            )

            self.assertEqualTransactionItems(actual, expected)

            actual = next(transaction_it)

            expected = TransactionItem(

                INSTALL,

                installed='lotus-3-16.x86_64',

                reason=libdnf.transaction.TransactionItemReason_USER

            )

            self.assertEqualTransactionItems(actual, expected)

            self.assertRaises(StopIteration, next, transaction_it)

    def test_history_undo_operations_downgrade_notavailable(self):

        """Test history_undo_operations with an unavailable downgrade."""

        operations = NEVRAOperations()

        operations.add('Downgrade', 'pepper-20-0.x86_64', 'pepper-20-2.x86_64')

        with self.base, self.assertRaises(PackagesNotAvailableError) as context:

            self.base._history_undo_operations(operations, 0)

        self.assertEqual(context.exception.pkg_spec, 'pepper-20-2.x86_64')

    def test_history_undo_operations_downgrade_notinstalled(self):

        """Test history_undo_operations with a not installed downgrade."""

        operations = NEVRAOperations()

        operations.add('Downgrade', 'lotus-3-0.x86_64', 'lotus-3-16.x86_64')

        with self.base, self.assertRaises(PackagesNotInstalledError) as context:

            self.base._history_undo_operations(operations, 0)

        self.assertEqual(context.exception.pkg_spec, 'lotus-3-0.x86_64')

    def test_history_undo_operations_erase(self):

        """Test history_undo_operations with an erase."""

        operations = NEVRAOperations()

        operations.add('Erase', 'lotus-3-16.x86_64')

        with self.base:

            self.base._history_undo_operations(operations, 0)

            transaction_it = iter(self.base.transaction)

            actual = next(transaction_it)

            expected = TransactionItem(

                INSTALL,

                installed='lotus-3-16.x86_64',

                reason=libdnf.transaction.TransactionItemReason_USER

            )

            self.assertEqualTransactionItems(actual, expected)

            self.assertRaises(StopIteration, next, transaction_it)

    def test_history_undo_operations_erase_twoavailable(self):

        """Test history_undo_operations with an erase available in two repos."""

        operations = NEVRAOperations()

        operations.add('Erase', 'lotus-3-16.x86_64')

        with self.base:

            self.base._history_undo_operations(operations, 0)

            transaction_it = iter(self.base.transaction)

            actual = next(transaction_it)

            expected = TransactionItem(

                INSTALL,

                installed='lotus-3-16.x86_64',

                reason=libdnf.transaction.TransactionItemReason_USER

            )

            self.assertEqualTransactionItems(actual, expected)

            self.assertRaises(StopIteration, next, transaction_it)

    def test_history_undo_operations_erase_notavailable(self):

        """Test history_undo_operations with an unavailable erase."""

        operations = NEVRAOperations()

        operations.add('Erase', 'hole-1-1.x86_64')

        with self.base, self.assertRaises(PackagesNotAvailableError) as context:

            self.base._history_undo_operations(operations, 0)

        self.assertEqual(context.exception.pkg_spec, 'hole-1-1.x86_64')

    def test_history_undo_operations_install(self):

        """Test history_undo_operations with an install."""

        operations = NEVRAOperations()

        operations.add('Install', 'pepper-20-0.x86_64', obsoleted_nevras=('lotus-3-16.x86_64',))

        with self.base:

            self.base._history_undo_operations(operations, 0)

            transaction_it = iter(self.base.transaction)

            actual = next(transaction_it)

            expected = TransactionItem(ERASE, erased='pepper-20-0.x86_64')

            self.assertEqualTransactionItems(actual, expected)

            actual = next(transaction_it)

            expected = TransactionItem(

                INSTALL,

                installed='lotus-3-16.x86_64',

                reason=libdnf.transaction.TransactionItemReason_USER

            )

            self.assertEqualTransactionItems(actual, expected)

            self.assertRaises(StopIteration, next, transaction_it)

    def test_history_undo_operations_install_notinstalled(self):

        """Test history_undo_operations with a not installed install."""

        operations = NEVRAOperations()

        operations.add('Install', 'mrkite-2-0.x86_64')

        with self.base, self.assertRaises(PackagesNotInstalledError) as context:

            self.base._history_undo_operations(operations, 0)

        self.assertEqual(context.exception.pkg_spec, 'mrkite-2-0.x86_64')

    def test_history_undo_operations_reinstall(self):

        """Test history_undo_operations with a reinstall."""

        operations = NEVRAOperations()

        operations.add(

            'Reinstall',

            'pepper-20-0.x86_64',

            'pepper-20-0.x86_64',

            ('hole-1-1.x86_64',)

        )

        with self.base:

            self.base._history_undo_operations(operations, 0)

            transaction_it = iter(self.base.transaction)

            actual = next(transaction_it)

            expected = TransactionItem(

                REINSTALL,

                installed='pepper-20-0.x86_64',

                erased='pepper-20-0.x86_64',

                obsoleted=('hole-1-1.x86_64',)

            )

            self.assertEqualTransactionItems(actual, expected)

            self.assertRaises(StopIteration, next, transaction_it)

    def test_history_undo_operations_reinstall_notavailable(self):

        """Test history_undo_operations with an unvailable reinstall."""

        operations = NEVRAOperations()

        operations.add('Reinstall', 'mrkite-2-0.x86_64', 'mrkite-2-0.x86_64')

        with self.base, self.assertRaises(PackagesNotInstalledError) as context:

            self.base._history_undo_operations(operations, 0)

        self.assertEqual(context.exception.pkg_spec, 'mrkite-2-0.x86_64')

    def test_history_undo_operations_reinstall_notinstalled(self):

        """Test history_undo_operations with a not installed reinstall."""

        operations = NEVRAOperations()

        operations.add('Reinstall', 'hole-1-1.x86_64', 'hole-1-1.x86_64')

        with self.base, self.assertRaises(PackagesNotAvailableError) as context:

            self.base._history_undo_operations(operations, 0)

        self.assertEqual(context.exception.pkg_spec, 'hole-1-1.x86_64')

    def test_history_undo_operations_reinstall_notinstalled_obsoleted(self):

        """Test history_undo_operations with a not installed obsoleted of a reinstall."""

        operations = NEVRAOperations()

        operations.add(

            'Reinstall',

            'pepper-20-0.x86_64',

            'pepper-20-0.x86_64',

            ('lotus-3-16.x86_64',)

        )

        with self.base:

            self.base._history_undo_operations(operations, 0)

            transaction_it = iter(self.base.transaction)

            actual = next(transaction_it)

            expected = TransactionItem(

                REINSTALL,

                installed='pepper-20-0.x86_64',

                erased='pepper-20-0.x86_64',

                obsoleted=()

            )

            self.assertEqualTransactionItems(actual, expected)

            self.assertRaises(StopIteration, next, transaction_it)

    def test_history_undo_operations_update(self):

        """Test history_undo_operations with an update."""

        operations = NEVRAOperations()

        operations.add('Update', 'tour-5-0.noarch', 'tour-4.6-1.noarch', ('lotus-3-16.x86_64',))

        with self.base:

            self.base._history_undo_operations(operations, 0)

            transaction_it = iter(self.base.transaction)

            actual = next(transaction_it)

            expected = TransactionItem(

                DOWNGRADE,

                installed='tour-4.6-1.noarch',

                erased='tour-5-0.noarch'

            )

            self.assertEqualTransactionItems(actual, expected)

            actual = next(transaction_it)

            expected = TransactionItem(

                INSTALL,

                installed='lotus-3-16.x86_64',

                reason=libdnf.transaction.TransactionItemReason_USER

            )

            self.assertEqualTransactionItems(actual, expected)

            self.assertRaises(StopIteration, next, transaction_it)

    def test_history_undo_operations_update_notavailable(self):

        """Test history_undo_operations with an unavailable update."""

        operations = NEVRAOperations()

        operations.add('Update', 'tour-5-0.noarch', 'tour-4.6-2.noarch')

        with self.base, self.assertRaises(PackagesNotAvailableError) as context:

            self.base._history_undo_operations(operations, 0)

        self.assertEqual(context.exception.pkg_spec, 'tour-4.6-2.noarch')

    def test_history_undo_operations_update_notinstalled(self):

        """Test history_undo_operations with a not installed update."""

        operations = NEVRAOperations()

        operations.add('Update', 'lotus-4-0.x86_64', 'lotus-3-16.x86_64')

        with self.base, self.assertRaises(PackagesNotInstalledError) as context:

            self.base._history_undo_operations(operations, 0)

        self.assertEqual(context.exception.pkg_spec, 'lotus-4-0.x86_64')

'''