#!/usr/bin/env python
# Copyright (C) 2014  Codethink Limited
#
# This program 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; version 2 of the License.
#
# This program 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 this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

import unittest

import pip_find_deps
from pkg_resources import parse_requirements, parse_version

def reverse(xs):
    return xs[::-1]

class ConflictDetectionTests(unittest.TestCase):

    def setUp(self):
        reqs = ['a == 0.1', 'a == 0.2']
        self.test_requirements = parse_requirements(reqs)

    def test_eqs_two_different_versions(self):
        # ('==', '0.1') conflicts with ('==', '0.2')
        deps = pip_find_deps.resolve_version_constraints(
                            self.test_requirements)

        self.assertEqual(len(deps), 1)

        _, dep = deps.popitem()

        self.assertEqual(len(dep.conflicts), 1)
        self.assertEqual(dep.conflicts, [(('==', parse_version('0.1')),
                                         ('==', parse_version('0.2')))])

    def run_conflict_test(self, requirements, expected_conflicts):
        deps = pip_find_deps.resolve_version_constraints(requirements)

        self.assertEqual(len(deps), 1)

        _, dep = deps.popitem()

        print 'requirements: ', requirements
        print 'expected_conflicts: ', expected_conflicts
        print 'dep.conflicts: ', dep.conflicts

        self.assertEqual(len(dep.conflicts), 1)
        self.assertEqual(dep.conflicts, expected_conflicts)

    # TODO: squash this into one?
    def test_less_than(self):
        requirements = list(parse_requirements(['a == 0.1', 'a < 0.1']))
        expected_conflict = (('==', parse_version('0.1')),
                              ('<', parse_version('0.1')))

        # ('==', '0.1') conflicts with ('<', 0.1)
        self.run_conflict_test(requirements, [expected_conflict])

        # ('<', 0.1) conflicts with ('==', '0.1')
        self.run_conflict_test(reverse(requirements), [reverse(expected_conflict)])

    def test_greater_than(self):
        requirements = list(parse_requirements(['a == 0.1', 'a > 0.1']))
        expected_conflict = (('==', parse_version('0.1')),
                               ('>', parse_version('0.1')))

        # ('==', '0.1') conflicts with ('>', 0.1)
        #self.run_conflict_test(requirements, [expected_conflict])

        # ('>', 0.1) conflicts with ('==', '0.1')
        #self.run_conflict_test(reverse(requirements), [reverse(expected_conflict)])

    def test_eqs_nt_eqs(self):
        requirements = list(parse_requirements(['a == 0.1', 'a != 0.1']))
        expected_conflict = (('==', parse_version('0.1')),
                              ('!=', parse_version('0.1')))

        # ('==', '0.1') conflicts with ('!=', '0.1')
        self.run_conflict_test(requirements, [expected_conflict])

        # ('!=', '0.1') conflicts with ('==', '0.1')
        self.run_conflict_test(reverse(requirements), [reverse(expected_conflict)])

    def test_bounds_one_version(self):
        requirements = list(parse_requirements(['a < 0.1', 'a > 0.1']))
        expected_conflict = (('<', parse_version('0.1')),
                             ('>', parse_version('0.1')))

        # ('<', '0.1') conflicts with ('>', '0.1')
        self.run_conflict_test(requirements, [expected_conflict])

        # ('>', '0.1') conflicts with ('<', '0.1')
        self.run_conflict_test(reverse(requirements), [reverse(expected_conflict)])

    def test_bounds_two_versions(self):
        requirements = list(parse_requirements(['a < 0.1', 'a > 0.2']))
        expected_conflict = (('<', parse_version('0.1')),
                             ('>', parse_version('0.2')))

        # ('<', '0.1') conflicts with ('>', '0.2')
        self.run_conflict_test(requirements, [expected_conflict])

        # ('>', '0.2') conflicts with ('<', '0.1')
        self.run_conflict_test(reverse(requirements), [reverse(expected_conflict)])

    def test_eqs_bounds_two_versions(self):
        requirements = list(parse_requirements(['a <= 0.1', 'a >= 0.2']))
        expected_conflict = (('<=', parse_version('0.1')),
                             ('>=', parse_version('0.2')))

        # ('<=', 0.1) conflicts with ('>=', 0.2)
        self.run_conflict_test(requirements, [expected_conflict])

        self.run_conflict_test(reverse(requirements), [reverse(expected_conflict)])

    def run_test_no_conflict(self, requirements):
        # No conflict expected here,
        # for now it's enough to see that the list of conflicts is empty
        deps = pip_find_deps.resolve_version_constraints(requirements)

        self.assertEqual(len(deps), 1)

        _, dep = deps.popitem()
        self.assertEqual(len(dep.conflicts), 0)

    def test_less_than_or_equal(self):
        requirements = list(parse_requirements(['a <= 0.1', 'a == 0.1']))

        self.run_test_no_conflict(requirements)
        self.run_test_no_conflict(reverse(requirements))

    def test_greater_than_or_equal(self):
        requirements = list(parse_requirements(['a >= 0.1', 'a == 0.1']))

        #self.run_test_no_conflict(requirements)
        #self.run_test_no_conflict(reverse(requirements))


if __name__ == '__main__':
    #suite = unittest.TestLoader().loadTestsFromTestCase(ConflictDetectionTests)
    suite = unittest.TestSuite()
    suite.addTest(ConflictDetectionTests('test_less_than_or_equal'))
    unittest.TextTestRunner(verbosity=2).run(suite)