示例#1
0
    def test_alias_get_set_del(self):
        src = dict(a=1)
        ad = aliasdict(src)

        # getitem and get on alias
        ad.alias(b=2)
        self.assertEqual(ad['b'], 2)
        self.assertEqual(ad.get('b'), 2)
        self.assertEqual(ad.aliases['b'], 2)

        # get with a default
        randomkey = str(uuid.uuid4())
        self.assertEqual(ad.get(randomkey), None)
        self.assertEqual(ad.get(randomkey, 1), 1)

        # set alias
        ad['b'] = 3
        self.assertEqual(ad['b'], 3)
        self.assertEqual(ad.aliases['b'], 3)

        # update alias
        ad.alias(b=4)
        self.assertEqual(ad['b'], 4)
        self.assertEqual(ad.aliases['b'], 4)

        # delete alias
        del ad['b']
        self.assertEqual(ad.get('b'), None)
示例#2
0
    def test_alias_concrete(self):
        src = dict(a=1)

        ad = aliasdict(src)
        ad.alias(b=2)

        self.assert_dict_interface(ad, src)
        self.assertEqual(ad['b'], 2)
示例#3
0
    def test_shadowing(self):
        "Alias keys take precedence."

        ad = aliasdict(a=1)
        ad.alias(a=2)

        self.assertEqual(ad['a'], 2)

        self.assertEqual(dict.__getitem__(ad, 'a'), 1)
示例#4
0
    def test_construction(self):
        # aliasdict can be constructed from a mapping/dict
        src = dict(a=1)
        ad = aliasdict(src)
        self.assert_dict_interface(ad, src)

        # aliasdict can be updated, without affecting the source dict
        ad.update(b=2)
        self.assertDictEqual(ad, dict(a=1, b=2))
        self.assertDictEqual(src, dict(a=1))

        # source dict can be updated without affecting the aliased dict
        src.update(c=3)
        self.assertDictEqual(ad, dict(a=1, b=2))
        self.assertDictEqual(src, dict(a=1, c=3))
示例#5
0
    def test_alias_callable(self):
        src = dict(a=1)

        ad = aliasdict(src)
        ad.alias(b=lambda d: d.get('a'))

        self.assert_dict_interface(ad, src)

        # 'b' equals 'a'
        self.assertEqual(ad['b'], ad['a'])
        self.assertEqual(ad['b'], src['a'])
        self.assertEqual(ad['b'], 1)

        # it's dynamic, works also when 'a' changes
        ad['a'] = 2
        self.assertEqual(ad['b'], ad['a'])
        self.assertNotEqual(ad['b'], src['a'])
        self.assertEqual(ad['b'], 2)
示例#6
0
    def _alias_result(self):
        """Alias `solutions` and `num_occurrences`.

        Deprecated in version 0.8.0.
        """
        if not self._result:
            return

        msg = "'{}' alias has been deprecated in favor of '{}'"
        samples_msg = msg.format('samples', 'solutions')
        occurrences_msg = msg.format('occurrences', 'num_occurrences')

        aliases = dict(samples=deprecated(samples_msg)(
            itemgetter('solutions')),
                       occurrences=deprecated(occurrences_msg)(
                           itemgetter('num_occurrences')))

        self._result = aliasdict(self._result)
        self._result.alias(aliases)

        return self._result
示例#7
0
    def test_copy(self):
        src = dict(a=1)
        aliases = dict(b=2)

        ad = aliasdict(src)
        ad.alias(**aliases)

        self.assertDictEqual(ad, src)
        self.assertDictEqual(ad.aliases, aliases)

        new = ad.copy()
        self.assertIsInstance(new, aliasdict)
        self.assertIsNot(new, ad)
        self.assertDictEqual(new, src)
        self.assertDictEqual(new.aliases, aliases)

        new = copy.deepcopy(ad)
        self.assertIsInstance(new, aliasdict)
        self.assertIsNot(new, ad)
        self.assertDictEqual(new, src)
        self.assertDictEqual(new.aliases, aliases)
示例#8
0
 def test_dict_interface(self):
     src = dict(a=1, b=2)
     ad = aliasdict(**src)
     self.assert_dict_interface(ad, src)