##############################################################################
#
# Copyright (c) Zope Foundation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
import unittest



class Test_default(unittest.TestCase):

    def _getTargetClass(self):
        from persistent.mapping import default
        return default

    def _makeOne(self, func):
        return self._getTargetClass()(func)

    def test___get___from_class(self):
        _called_with = []
        def _test(inst):
            _called_with.append(inst)
            return '_test'
        descr = self._makeOne(_test)
        class Foo(object):
            testing = descr
        self.assertTrue(Foo.testing is descr)
        self.assertEqual(_called_with, [])

    def test___get___from_instance(self):
        _called_with = []
        def _test(inst):
            _called_with.append(inst)
            return 'TESTING'
        descr = self._makeOne(_test)
        class Foo(object):
            testing = descr
        foo = Foo()
        self.assertEqual(foo.testing, 'TESTING')
        self.assertEqual(_called_with, [foo])


class PersistentMappingTests(unittest.TestCase):

    def _getTargetClass(self):
        from persistent.mapping import PersistentMapping
        return PersistentMapping

    def _makeOne(self, *args, **kw):
        return self._getTargetClass()(*args, **kw)

    def test_volatile_attributes_not_persisted(self):
        # http://www.zope.org/Collectors/Zope/2052
        m = self._makeOne()
        m.foo = 'bar'
        m._v_baz = 'qux'
        state = m.__getstate__()
        self.assertTrue('foo' in state)
        self.assertFalse('_v_baz' in state)

    def testTheWorld(self):
        from persistent._compat import PYTHON2
        # Test constructors
        l0 = {}
        l1 = {0:0}
        l2 = {0:0, 1:1}
        u = self._makeOne()
        u0 = self._makeOne(l0)
        u1 = self._makeOne(l1)
        u2 = self._makeOne(l2)

        uu = self._makeOne(u)
        uu0 = self._makeOne(u0)
        uu1 = self._makeOne(u1)
        uu2 = self._makeOne(u2)

        class OtherMapping(dict):
            def __init__(self, initmapping):
                self.__data = initmapping
            def items(self):
                return self.__data.items()
        v0 = self._makeOne(OtherMapping(u0))
        vv = self._makeOne([(0, 0), (1, 1)])

        # Test __repr__
        eq = self.assertEqual

        eq(str(u0), str(l0), "str(u0) == str(l0)")
        eq(repr(u1), repr(l1), "repr(u1) == repr(l1)")

        # Test __cmp__ and __len__

        if PYTHON2:
            def mycmp(a, b):
                r = cmp(a, b)
                if r < 0: return -1
                if r > 0: return 1
                return r

            all = [l0, l1, l2, u, u0, u1, u2, uu, uu0, uu1, uu2]
            for a in all:
                for b in all:
                    eq(mycmp(a, b), mycmp(len(a), len(b)),
                        "mycmp(a, b) == mycmp(len(a), len(b))")

        # Test __getitem__

        for i in range(len(u2)):
            eq(u2[i], i, "u2[i] == i")

        # Test get

        for i in range(len(u2)):
            eq(u2.get(i), i, "u2.get(i) == i")
            eq(u2.get(i, 5), i, "u2.get(i, 5) == i")

        for i in min(u2)-1, max(u2)+1:
            eq(u2.get(i), None, "u2.get(i) == None")
            eq(u2.get(i, 5), 5, "u2.get(i, 5) == 5")

        # Test __setitem__

        uu2[0] = 0
        uu2[1] = 100
        uu2[2] = 200

        # Test __delitem__

        del uu2[1]
        del uu2[0]
        try:
            del uu2[0]
        except KeyError:
            pass
        else:
            raise TestFailed("uu2[0] shouldn't be deletable")

        # Test __contains__
        for i in u2:
            self.assertTrue(i in u2, "i in u2")
        for i in min(u2)-1, max(u2)+1:
            self.assertTrue(i not in u2, "i not in u2")

        # Test update

        l = {"a":"b"}
        u = self._makeOne(l)
        u.update(u2)
        for i in u:
            self.assertTrue(i in l or i in u2, "i in l or i in u2")
        for i in l:
            self.assertTrue(i in u, "i in u")
        for i in u2:
            self.assertTrue(i in u, "i in u")

        # Test setdefault

        x = u2.setdefault(0, 5)
        eq(x, 0, "u2.setdefault(0, 5) == 0")

        x = u2.setdefault(5, 5)
        eq(x, 5, "u2.setdefault(5, 5) == 5")
        self.assertTrue(5 in u2, "5 in u2")

        # Test pop

        x = u2.pop(1)
        eq(x, 1, "u2.pop(1) == 1")
        self.assertTrue(1 not in u2, "1 not in u2")

        try:
            u2.pop(1)
        except KeyError:
            pass
        else:
            self.fail("1 should not be poppable from u2")

        x = u2.pop(1, 7)
        eq(x, 7, "u2.pop(1, 7) == 7")

        # Test popitem

        items = list(u2.items())
        key, value = u2.popitem()
        self.assertTrue((key, value) in items, "key, value in items")
        self.assertTrue(key not in u2, "key not in u2")

        # Test clear

        u2.clear()
        eq(u2, {}, "u2 == {}")

    def test___repr___converts_legacy_container_attr(self):
        # In the past, PM used a _container attribute. For some time, the
        # implementation continued to use a _container attribute in pickles
        # (__get/setstate__) to be compatible with older releases.  This isn't
        # really necessary any more. In fact, releases for which this might
        # matter can no longer share databases with current releases.  Because
        # releases as recent as 3.9.0b5 still use _container in saved state, we
        # need to accept such state, but we stop producing it.
        pm = self._makeOne()
        self.assertEqual(pm.__dict__, {'data': {}})
        # Make it look like an older instance
        pm.__dict__.clear()
        pm.__dict__['_container'] = {'a': 1}
        self.assertEqual(pm.__dict__, {'_container': {'a': 1}})
        pm._p_changed = 0
        self.assertEqual(repr(pm), "{'a': 1}")
        self.assertEqual(pm.__dict__, {'data': {'a': 1}})
        self.assertEqual(pm.__getstate__(), {'data': {'a': 1}})


class Test_legacy_PersistentDict(unittest.TestCase):

    def _getTargetClass(self):
        from persistent.dict import PersistentDict
        return PersistentDict

    def test_PD_is_alias_to_PM(self):
        from persistent.mapping import PersistentMapping
        self.assertTrue(self._getTargetClass() is PersistentMapping)


def test_suite():
    return unittest.TestSuite((
        unittest.makeSuite(Test_default),
        unittest.makeSuite(PersistentMappingTests),
        unittest.makeSuite(Test_legacy_PersistentDict),
    ))