Merge lp:~thisfred/desktopcouch/a-b-c-1-2-3 into lp:desktopcouch

[Eric Casteleijn]

Makes RecordDict and MergeableList use Abstract Base Classes, so the code is smaller, and the interfaces are more guaranteed.

Makes RecordDict and MergeableList use Abstract Base Classes, so the code is smaller, and the interfaces are more guaranteed.

Note this has some small and rather trivial lint issues, which I have already fixed on other branches, and I don't want to generate more conflicts than I have to.

[Manuel de la Peña (mandel)]

+1, good job you workaholic!

review: Approve

[Nicola Larosa (teknico)]

You might want to add a comment to record.py, right before importing MutableSequence and MutableMapping, to the effect that it requires at least Python 2.6 .

This will make this and subsequent versions of desktopcouch not usable by ubuntuone-servers, until all server machines are upgraded to Lucid (10.04).

[Vincenzo Di Somma (vds)]

review: Approve

=== modified file 'desktopcouch/records/doc/field_registry.txt'
--- desktopcouch/records/doc/field_registry.txt	2010-11-10 19:33:59 +0000
+++ desktopcouch/records/doc/field_registry.txt	2010-11-22 03:51:10 +0000
@@ -172,7 +172,7 @@
 ...        losslessly as possible.
 ...     """
 ...
-...     def getValue(self, record):
+...     def get_value(self, record):
 ...         """Get the value for the registered field."""
 ...         score = record.get(self._fieldname)
 ...         stars = score / 20
@@ -181,7 +181,7 @@
 ...             stars += 1
 ...         return "*" * stars
 ...
-...     def setValue(self, record, value):
+...     def set_value(self, record, value):
 ...         """Set the value for the registered field."""
 ...         if value is None:
 ...             self.deleteValue(record)

=== modified file 'desktopcouch/records/field_registry.py'
--- desktopcouch/records/field_registry.py	2010-11-10 19:33:59 +0000
+++ desktopcouch/records/field_registry.py	2010-11-22 03:51:10 +0000
@@ -20,6 +20,7 @@
 """Registry utility classes"""
 
 import copy
+import warnings
 
 from desktopcouch.records.record import MergeableList
 ANNOTATION_NAMESPACE = 'application_annotations'
@@ -41,7 +42,7 @@
             record = self.record_class()
         for key, val in data.items():
             if key in self.field_registry:
-                self.field_registry[key].setValue(record, val)
+                self.field_registry[key].set_value(record, val)
             else:
                 record.application_annotations.setdefault(
                     self.app_name, {}).setdefault(
@@ -57,7 +58,7 @@
         for key, value in annotations.items():
             data[key] = value
         for key in self.field_registry:
-            data[key] = self.field_registry[key].getValue(record)
+            data[key] = self.field_registry[key].get_value(record)
         return data
 
 
@@ -68,22 +69,43 @@
         """initialize the fieldname"""
         self._fieldname = fieldname
 
-    def getValue(self, record):
+    def get_value(self, record):
         """get the value for the registered field"""
         return record.get(self._fieldname)
 
-    def deleteValue(self, record):
+    def getValue(self, record):         # pylint: disable=C0103
+        """Deprecated"""
+        warnings.warn(
+            ".getValue is deprecated, use .get_value instead",
+            DeprecationWarning, stacklevel=2)
+        return self.get_value(record)
+
+    def delete_value(self, record):
         """Delete a value"""
         if self._fieldname in record:
             del record[self._fieldname]
 
-    def setValue(self, record, value):
+    def deleteValue(self, record):      # pylint: disable=C0103
+        """Deprecated."""
+        warnings.warn(
+            ".deleteValue is deprecated, use .delete_value instead",
+            DeprecationWarning, stacklevel=2)
+        return self.delete_value(record)
+
+    def set_value(self, record, value):
         """set the value for the registered field"""
         if value is None:
-            self.deleteValue(record)
+            self.delete_value(record)
             return
         record[self._fieldname] = value
 
+    def setValue(self, record, value):  # pylint: disable=C0103
+        """Deprecated."""
+        warnings.warn(
+            ".setValue is deprecated, use .set_value instead",
+            DeprecationWarning, stacklevel=2)
+        return self.set_value(record, value)
+
 
 class MergeableListFieldMapping(object):
     """Mapping between MergeableLists and application fields."""
@@ -104,13 +126,13 @@
         private = annotation.setdefault('private_application_annotations', {})
         return private
 
-    def _uuidLookup(self, record):
-        """return the uuid key to lookup the registered field"""
+    def _uuid_lookup(self, record):
+        """Return the uuid key to lookup the registered field."""
         return self.get_application_annotations(record).get(self._uuid_field)
 
-    def getValue(self, record):
-        """get the value for the registered field"""
-        uuid_key = self._uuidLookup(record)
+    def get_value(self, record):
+        """Get the value for the registered field."""
+        uuid_key = self._uuid_lookup(record)
         try:
             return record[
                 self._root_list].get_value_for_uuid(uuid_key).get(
@@ -118,12 +140,19 @@
         except KeyError:
             return None
 
-    def deleteValue(self, record):
+    def getValue(self, record):         # pylint: disable=C0103
+        """Deprecated"""
+        warnings.warn(
+            ".getValue is deprecated, use .get_value instead",
+            DeprecationWarning, stacklevel=2)
+        return self.get_value(record)
+
+    def delete_value(self, record):
         """Delete a value"""
         root_list = record.get(self._root_list, None)
         if not root_list:
             return
-        uuid_key = self._uuidLookup(record)
+        uuid_key = self._uuid_lookup(record)
         if not uuid_key:
             return
         # pylint: disable=W0212
@@ -131,10 +160,17 @@
             del root_list._data[uuid_key][self._field_name]
         # pylint: enable=W0212
 
-    def setValue(self, record, value):
-        """set the value for the registered field"""
+    def deleteValue(self, record):      # pylint: disable=C0103
+        """Deprecated."""
+        warnings.warn(
+            ".deleteValue is deprecated, use .delete_value instead",
+            DeprecationWarning, stacklevel=2)
+        return self.delete_value(record)
+
+    def set_value(self, record, value):
+        """Set the value for the registered field."""
         if not value:
-            self.deleteValue(record)
+            self.delete_value(record)
             return
         root_list = record.get(self._root_list, None)
         application_annotations = self.get_application_annotations(record)
@@ -142,12 +178,12 @@
         values.update({self._field_name: value})
         if not root_list:
             # This is the first value we add to the list
-            ml = MergeableList.from_list([values])
+            ml = MergeableList([values])
             record[self._root_list] = ml
             uuid_key = record[self._root_list].get_uuid_for_index(-1)
             application_annotations[self._uuid_field] = uuid_key
             return
-        uuid_key = self._uuidLookup(record)
+        uuid_key = self._uuid_lookup(record)
         if not uuid_key:
             # We add a new value to an existing list
             root_list.append(values)
@@ -164,3 +200,10 @@
             application_annotations[self._uuid_field] = uuid_key
             return
         record_dict[self._field_name] = value
+
+    def setValue(self, record, value):  # pylint: disable=C0103
+        """Deprecated."""
+        warnings.warn(
+            ".setValue is deprecated, use .set_value instead",
+            DeprecationWarning, stacklevel=2)
+        return self.set_value(record, value)

=== modified file 'desktopcouch/records/record.py'
--- desktopcouch/records/record.py	2010-11-15 23:19:39 +0000
+++ desktopcouch/records/record.py	2010-11-22 03:51:10 +0000
@@ -23,7 +23,11 @@
 
 import re
 import uuid
+import warnings
+
 from time import strptime
+from collections import MutableSequence, MutableMapping
+
 
 RX = re.compile('[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}')
 
@@ -35,17 +39,34 @@
         key.startswith(('_', 'application_annotations')))
 
 
+def is_mergeable_list(dictionary):
+    """Tests wether the dictionary represents a mergeable list."""
+    if not dictionary:
+        return False
+    if not isinstance(dictionary, MutableMapping):
+        return False
+    if not '_order' in dictionary:
+        for key in dictionary:
+            if not RX.match(key):
+                return False
+    for key in dictionary:
+        if not key == '_order' and not RX.match(key):
+            return False
+    return True
+
+
 def is_uuid_dict(dictionary):
-    """Test whether the passed object is a dictionary like object with
-    uuids for keys.
-    """
+    """Deprecated."""
+    warnings.warn(
+        ".is_uuid_dict is deprecated, use .is_mergeable_list instead",
+        DeprecationWarning, stacklevel=2)
     return dictionary and not [
         key for key in dictionary if (not RX.match(key) and key != '_order')]
 
 
 def record_factory(data):
     """Create a RecordDict or RecordList from passed data."""
-    if isinstance(data, dict):
+    if isinstance(data, MutableMapping):
         return _build_from_dict(data)
     return data
 
@@ -63,8 +84,8 @@
 
 def validate(data):
     """Validate underlying data for Record objects."""
-    if isinstance(data, dict):
-        if is_uuid_dict(data):
+    if isinstance(data, MutableMapping):
+        if is_mergeable_list(data):
             return
         if any(RX.match(key) for key in data):
             raise IllegalKeyException(
@@ -163,8 +184,8 @@
 
     def __getitem__(self, key):
         value = self._data[key]
-        if isinstance(value, dict):
-            if is_uuid_dict(value):
+        if isinstance(value, MutableMapping):
+            if is_mergeable_list(value):
                 result = MergeableList(value)
             else:
                 result = RecordDict(value)
@@ -172,7 +193,7 @@
         return value
 
     def __setitem__(self, key, item):
-        if isinstance(item, dict):
+        if isinstance(item, MutableMapping):
             item = record_factory(item)
         if hasattr(item, '_data'):
             item = item._data           # pylint: disable=W0212
@@ -181,11 +202,8 @@
     def __delitem__(self, key):
         del self._data[key]
 
-    def __len__(self):
-        return len(self._data)
-
-
-class RecordDict(RecordData):
+
+class RecordDict(RecordData, MutableMapping):
     """An object that represents an desktop CouchDB record fragment,
     but behaves like a dictionary.
 
@@ -201,62 +219,33 @@
         for key in self._data:
             yield key
 
-    def __contains__(self, key):
-        return key in self._data
-
-    def __cmp__(self, value):
-        if isinstance(value, RecordDict):
-            return cmp(self._data, value._data)  # pylint: disable=W0212
-        return -1
-
-    def get(self, key, default=None):
-        """D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None."""
-        if not key in self._data:
-            return default
-        return self[key]
-
-    def update(self, data):
-        """D.update(E, **F) -> None.  Update D from dict/iterable E and F.
-
-        If E has a .keys() method, does:     for k in E: D[k] = E[k]
-        If E lacks .keys() method, does:     for (k, v) in E: D[k] = v
-        In either case, this is followed by: for k in F: D[k] = F[k]
-
-        """
-        for key, val in data.items():
-            self[key] = val
-
-    def items(self):
-        """D.items() -> list of D's (key, value) pairs, as 2-tuples."""
-        return [(key, self[key]) for key in self]
-
-    def keys(self):
-        """D.keys() -> list of D's keys."""
-        return self._data.keys()
-
-    def setdefault(self, key, default):
+    def __len__(self):
+        return len(self._data)
+
+    def setdefault(self, key, default=None):
         """D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D."""
-        if not key in self:
+        try:
+            return self[key]
+        except KeyError:
             self[key] = default
+        # NOTE: since we (possibly) mangle the default value in
+        # __setitem__, we can't just 'return default' here, as
+        # MutableMapping does.
         return self[key]
 
-    def has_key(self, key):
-        """D.has_key(k) -> True if D has a key k, else False."""
-        return key in self
-
-
-class MergeableList(RecordData):
+
+class MergeableList(RecordData, MutableSequence):
     """An object that represents a list of complex values."""
 
-    @classmethod
-    def from_list(cls, data):
-        """Create a RecordList from passed data."""
-        if not data:
-            raise ValueError("Can't set empty list values.'")
-        result = cls({})
-        for value in data:
-            result.append(record_factory(value))
-        return result
+    def __init__(self, data):
+        if isinstance(data, MutableMapping):
+            super(MergeableList, self).__init__(data)
+        else:
+            self._data = {}
+            for value in data:
+                self.append(record_factory(value))
+            self._attachments = dict()
+            self._detached = set()
 
     def __getitem__(self, index):
         if not isinstance(index, int):
@@ -265,12 +254,12 @@
         key = self.get_uuid_for_index(index)
         return super(MergeableList, self).__getitem__(key)
 
-    def __setitem__(self, index, item):
+    def __setitem__(self, index, value):
         if not isinstance(index, int):
             raise TypeError(
                 "list indices must be integers, not %s" % type(index))
         key = self.get_uuid_for_index(index)
-        super(MergeableList, self).__setitem__(key, item)
+        super(MergeableList, self).__setitem__(key, value)
 
     def __delitem__(self, index):
         if not isinstance(index, int):
@@ -281,37 +270,19 @@
             self._data['_order'].remove(key)
         super(MergeableList, self).__delitem__(key)
 
-    def __iter__(self):
-        return (self[index] for index in range(len(self)))
-
     def __len__(self):
-        length = len(self._data)
         if '_order' in self._data:
-            return length - 1
-        return length
-
-    def __contains__(self, value):
-        if hasattr(value, '_data'):
-            value = value._data         # pylint: disable=W0212
-        return value in self._data.values()
-
-    def __cmp__(self, value):
-        """
-        Implement the compare to be able to compare with other mergeable
-        lists, tuples and lists.
-        """
-        if (hasattr(value, "__iter__")
-            and hasattr(value, "__getitem__")
-            and hasattr(value, "__len__")):
-            # we should have the same value in the same order
-            length = len(value)
-            if len(self) == length:
-                for index in range(len(self)):
-                    cmp_value = cmp(self[index], value[index])
-                    if cmp_value != 0:
-                        return cmp_value
-                return 0
-        return -1
+            return len(self._data) - 1
+        return len(self._data)
+
+    def insert(self, index, value):
+        """Insert value at index."""
+        new_uuid = str(uuid.uuid4())
+        if not '_order' in self._data:
+            self._data['_order'] = sorted(
+                [key for key in self._data.keys() if RX.match(key)])
+        self._data['_order'].insert(index, new_uuid)
+        super(MergeableList, self).__setitem__(new_uuid, value)
 
     def _get_ordered_keys(self):
         """Get list of uuid keys ordered by 'order' property or uuid key."""
@@ -334,53 +305,6 @@
         """
         return super(MergeableList, self).__getitem__(lookup_uuid)
 
-    def append(self, value):
-        """L.append(object) -- append object to end."""
-        new_uuid = str(uuid.uuid4())
-        self._data.setdefault('_order', sorted(self._data.keys())).append(
-            new_uuid)
-        super(MergeableList, self).__setitem__(new_uuid, value)
-
-    def remove(self, value):
-        """L.remove(value) -- remove first occurrence of value.
-
-        Raises ValueError if the value is not present.
-
-        """
-        if len(self) == 1:
-            raise ValueError("MergeableList cannot be empty.")
-        index = 0
-        for current_value in self:
-            # important! use the data in self first 'cause mergeable lists
-            # can be compared with list and tuples but no the other way around
-            if cmp(current_value, value) == 0:
-                del self[index]
-                return
-            index += 1
-        raise ValueError("list.remove(x): x not in list")
-
-    def pop(self, index=None):
-        """L.pop([index]) -> item -- remove and return item at
-        index. (default last.)
-
-        Raises IndexError if list is empty or index is out of range.
-        """
-        if len(self) == 1:
-            raise ValueError("MergeableList cannot be empty.")
-        if index is None:
-            index = -1
-        value = self[index]
-        del self[index]
-        return value
-
-    def index(self, key):
-        """L.index(value, [start, [stop]]) -> integer -- return first
-        index of value.
-
-        Raises ValueError if the value is not present.
-        """
-        return self.__getitem__(key)
-
 
 class Record(RecordDict):
     """An object that represents a Desktop CouchDB record."""

=== modified file 'desktopcouch/records/server_base.py'
--- desktopcouch/records/server_base.py	2010-11-18 18:32:29 +0000
+++ desktopcouch/records/server_base.py	2010-11-22 03:51:10 +0000
@@ -215,7 +215,8 @@
             wrapper=None, **options):
         """Pass-through to CouchDB library.  Deprecated."""
         warnings.warn(
-            "._temporary_query is deprecated.", DeprecationWarning)
+            "._temporary_query is deprecated.", DeprecationWarning,
+            stacklevel=2)
         return self.db.query(map_fun, reduce_fun, language,
                              wrapper, **options)
 
@@ -520,7 +521,7 @@
         """
         warnings.warn(
             ".get_records is deprecated, use .get_all_records instead",
-            DeprecationWarning)
+            DeprecationWarning, stacklevel=2)
         view_name = "get_records_and_type"
         view_map_js = """
             function(doc) {

=== modified file 'desktopcouch/records/tests/test_field_registry.py'
--- desktopcouch/records/tests/test_field_registry.py	2010-11-12 14:36:14 +0000
+++ desktopcouch/records/tests/test_field_registry.py	2010-11-22 03:51:10 +0000
@@ -32,6 +32,9 @@
     'record_type': 'http://example.com/test',
     'simple_field': 23,
     'test_fields': {
+        '_order': [
+            'd6d2c23b-279c-45c8-afb2-ec84ee7c81c3',
+            'e47455fb-da05-481e-a2c7-88f14d5cc163'],
         'e47455fb-da05-481e-a2c7-88f14d5cc163':
             {'the_field': 'the value',
              'not_the_field': 'different value'},
@@ -79,20 +82,20 @@
         """Test the simple field mapping object."""
         r = Record(self.test_record)
         mapping = SimpleFieldMapping('simple_field')
-        self.assertEqual(23, mapping.getValue(r))
-        mapping.setValue(r, 'Fnord')
-        self.assertEqual('Fnord', mapping.getValue(r))
+        self.assertEqual(23, mapping.get_value(r))
+        mapping.set_value(r, 'Fnord')
+        self.assertEqual('Fnord', mapping.get_value(r))
 
     def test_mergeable_list_field_mapping0(self):
         """Test the MergeableListFieldMapping object."""
         record = Record(self.test_record)
         mapping = MergeableListFieldMapping(
             'Test App', 'test_field', 'test_fields', 'the_field')
-        self.assertEqual('the value', mapping.getValue(record))
-        mapping.setValue(record, 'a new value')
-        self.assertEqual('a new value', mapping.getValue(record))
-        mapping.deleteValue(record)
-        self.assertEqual(None, mapping.getValue(record))
+        self.assertEqual('the value', mapping.get_value(record))
+        mapping.set_value(record, 'a new value')
+        self.assertEqual('a new value', mapping.get_value(record))
+        mapping.delete_value(record)
+        self.assertEqual(None, mapping.get_value(record))
 
     def test_mergeable_list_field_mapping1(self):
         """Test the MergeableListFieldMapping object."""
@@ -100,11 +103,11 @@
         record = Record(self.test_record)
         mapping = MergeableListFieldMapping(
             'Test App', 'test_field', 'test_fields', 'the_field')
-        self.assertEqual('the value', mapping.getValue(record))
+        self.assertEqual('the value', mapping.get_value(record))
         del record._data['test_fields'][  # pylint: disable=W0212
             'e47455fb-da05-481e-a2c7-88f14d5cc163']
-        mapping.deleteValue(record)
-        self.assertEqual(None, mapping.getValue(record))
+        mapping.delete_value(record)
+        self.assertEqual(None, mapping.get_value(record))
         # pylint: enable=W0212
 
     def test_mergeable_list_field_mapping_empty_field(self):
@@ -112,8 +115,8 @@
         record = Record(self.test_record)
         mapping = MergeableListFieldMapping(
             'Test App', 'test_field', 'test_fields', 'the_field')
-        mapping.setValue(record, '')
-        self.assertEqual(None, mapping.getValue(record))
+        mapping.set_value(record, '')
+        self.assertEqual(None, mapping.get_value(record))
 
 
 class TestTransformer(TestCase):

=== modified file 'desktopcouch/records/tests/test_record.py'
--- desktopcouch/records/tests/test_record.py	2010-11-15 22:39:27 +0000
+++ desktopcouch/records/tests/test_record.py	2010-11-22 03:51:10 +0000
@@ -22,16 +22,125 @@
 import doctest
 import os
 from testtools import TestCase
+from collections import MutableSequence, MutableMapping
 
-# pylint does not like relative imports from containing packages
-# pylint: disable=F0401
 import desktopcouch
 from desktopcouch.records.server import CouchDatabase
 from desktopcouch.records.record import (Record, RecordDict, MergeableList,
-    record_factory, IllegalKeyException, validate, NoRecordTypeSpecified)
+    record_factory, IllegalKeyException, validate, NoRecordTypeSpecified,
+    is_mergeable_list)
 import desktopcouch.tests as test_environment
 
 
+class TestRecordDict(TestCase):
+    """Test the record dictionary functionality."""
+
+    def test_abc(self):
+        """Test RecordDict is a mutable mapping."""
+        record_dict = RecordDict({})
+        self.assertTrue(isinstance(record_dict, MutableMapping))
+
+
+class TestMergeableList(TestCase):
+    """Test the mergeable list functionality."""
+
+    def test_is_mergeable_list(self):
+        """Test the is_mergeable_list checker."""
+        self.assertTrue(is_mergeable_list({'_order': []}))
+        self.assertTrue(is_mergeable_list({
+            '_order': [
+                'd6d2c23b-279c-45c8-afb2-ec84ee7c81c3',
+                'e47455fb-da05-481e-a2c7-88f14d5cc163'],
+            'd6d2c23b-279c-45c8-afb2-ec84ee7c81c3': 'foo',
+            'e47455fb-da05-481e-a2c7-88f14d5cc163': 'baz'}))
+        self.assertFalse(is_mergeable_list(None))
+        self.assertFalse(is_mergeable_list({}))
+        self.assertFalse(is_mergeable_list({
+            'foo': 'bar',
+            'baz': 'qux'}))
+
+    def test_abc(self):
+        """Test MergeableList is a mutable sequence."""
+        mergeable_list = MergeableList(['foo', 'bar'])
+        self.assertTrue(isinstance(mergeable_list, MutableSequence))
+
+    def test_insert(self):
+        """Test the insert method."""
+        mergeable_list = MergeableList(['foo', 'bar'])
+        mergeable_list.insert(0, 'baz')
+        self.assertEquals(
+            ['baz', 'foo', 'bar'], [item for item in mergeable_list])
+
+        mergeable_list.insert(-1, 'qux')
+        self.assertEquals(
+            ['baz', 'foo', 'qux', 'bar'],
+            [item for item in mergeable_list])
+        mergeable_list.insert(2, 'fnord')
+        self.assertEquals(
+            ['baz', 'foo', 'fnord', 'qux', 'bar'],
+            [item for item in mergeable_list])
+
+    def test_index(self):
+        """Test the subset of list behavior we'll be supporting"""
+        mergeable_list = MergeableList(['foo', 'bar'])
+        self.assertEqual("foo", mergeable_list[0])
+        self.assertEqual("bar", mergeable_list[1])
+        self.assertEqual("bar", mergeable_list[-1])
+
+    def test_del(self):
+        """Test deletion of uuid keys."""
+        mergeable_list = MergeableList(['foo', 'bar', 'baz'])
+        del mergeable_list[1]
+        self.assertEqual(2, len(mergeable_list))
+        self.assertEqual("foo", mergeable_list[0])
+        self.assertEqual("baz", mergeable_list[1])
+
+    def test_append(self):
+        """Test append."""
+        mergeable_list = MergeableList(['foo', 'bar'])
+        mergeable_list.append('baz')
+        self.assertEqual(3, len(mergeable_list))
+        self.assertEqual('baz', mergeable_list[-1])
+
+    def test_remove(self):
+        """Test remove a normal value"""
+        mergeable_list = MergeableList(['foo', 'bar'])
+        value = 'baz'
+        mergeable_list.append(value)
+        mergeable_list.remove(value)
+        self.assertFalse(value in mergeable_list)
+
+    def test_remove_missing(self):
+        """Test missing data rmeoval"""
+        mergeable_list = MergeableList(['foo', 'bar'])
+        self.assertRaises(ValueError, mergeable_list.remove, 'qux')
+
+    def test_pop(self):
+        """Test the pop method when working with a correct index."""
+        value = [1, 2, 3, 4, 5]
+        mergeable_list = MergeableList(value)
+        # test with negative index
+        popped_value = mergeable_list.pop(-2)
+        self.assertEqual(value[-2], popped_value)
+        # test with positive index
+        popped_value = mergeable_list.pop(1)
+        self.assertEqual(value[1], popped_value)
+
+    def test_pop_wrong_index(self):
+        """Test pop when index is out or range."""
+        value = [1, 2, 3, 4, 5]
+        mergeable_list = MergeableList(value)
+        self.assertRaises(IndexError, mergeable_list.pop,
+            len(value) * 2)
+
+    def test_pop_no_index(self):
+        """Test pop without an index argument."""
+        value = [1, 2, 3, 4, 5]
+        mergeable_list = MergeableList(value)
+        popped_value = mergeable_list.pop()
+        self.assertEqual(value[-1], popped_value)
+
+
 class TestRecords(TestCase):
     """Test the record functionality"""
 
@@ -46,12 +155,15 @@
                     "field11s": "value11s",
                     "field12s": "value12s"},
             "subfield_uuid": {
-                    "e47455fb-da05-481e-a2c7-88f14d5cc163": {
-                        "field11": "value11",
-                        "field12": "value12"},
-                    "d6d2c23b-279c-45c8-afb2-ec84ee7c81c3": {
-                        "field21": "value21",
-                        "field22": "value22"}},
+                '_order': [
+                    'd6d2c23b-279c-45c8-afb2-ec84ee7c81c3',
+                    'e47455fb-da05-481e-a2c7-88f14d5cc163'],
+                "e47455fb-da05-481e-a2c7-88f14d5cc163": {
+                    "field11": "value11",
+                    "field12": "value12"},
+                "d6d2c23b-279c-45c8-afb2-ec84ee7c81c3": {
+                    "field21": "value21",
+                    "field22": "value22"}},
             "application_annotations": {
                 "my_awesome_app": {"foo": "bar", "some_setting": "set_to"}},
             "record_type": "http://fnord.org/smorgasbord",
@@ -158,113 +270,6 @@
         """Are subdicts with multiple entries supported?"""
         self.assertEqual(2, len(self.record["subfield_uuid"]))
 
-    def test_mergeable_list_index(self):
-        """Test the subset of list behavior we'll be supporting"""
-        self.assertEqual("value21", self.record["subfield_uuid"][0]["field21"])
-        self.assertEqual("value22", self.record["subfield_uuid"][0]["field22"])
-        self.assertEqual("value11", self.record["subfield_uuid"][-1]["field11"])
-        self.assertEqual("value12", self.record["subfield_uuid"][-1]["field12"])
-
-    def test_mergeable_list_del(self):
-        """Test deletion of uuid keys."""
-        del self.record["subfield_uuid"][0]
-        self.assertEqual(1, len(self.record["subfield_uuid"]))
-        self.assertEqual("value11", self.record["subfield_uuid"][0]["field11"])
-        self.assertEqual("value12", self.record["subfield_uuid"][0]["field12"])
-
-    def test_mergeable_list_set_value_in_list_item(self):
-        """Test assignment by index."""
-        self.record["subfield_uuid"][0]["field12"] = "new exciting value"
-        self.assertEqual(
-            "new exciting value", self.record["subfield_uuid"][0]["field12"])
-
-    def test_mergeable_list_append(self):
-        """Test append."""
-        self.record["subfield_uuid"].append(
-            {"field31": "value31", "field32": "value32"})
-        self.assertEqual(3, len(self.record["subfield_uuid"]))
-        self.assertEqual("value32", self.record["subfield_uuid"][-1]["field32"])
-
-    def test_mergeable_list_append_record_dict(self):
-        """Test appending a RecordDict value."""
-        value = RecordDict({
-            "field31": "value31",
-            "field32": "value32"})
-        self.record["subfield_uuid"].append(value)
-        self.assertEqual(3, len(self.record["subfield_uuid"]))
-        self.assertEqual("value32", self.record["subfield_uuid"][-1]["field32"])
-
-    def test_mergeable_list_remove(self):
-        """Test remove a normal value"""
-        value = "string"
-        self.record["subfield_uuid"].append(value)
-        self.record["subfield_uuid"].remove(value)
-        self.assertFalse(value in self.record["subfield_uuid"])
-
-    def test_mergeable_list_remove_record_dict(self):
-        """Test remove a RecordDict value"""
-        value = RecordDict({
-            "field31": "value31",
-            "field32": "value32"})
-        self.record["subfield_uuid"].append(value)
-        self.record["subfield_uuid"].remove(value)
-        self.assertFalse(value in self.record["subfield_uuid"])
-
-    def test_mergeable_list_remove_list(self):
-        """Test list removal"""
-        value = [1, 2, 3, 4, 5]
-        self.record["subfield_uuid"].append(value)
-        self.record["subfield_uuid"].remove(value)
-        self.assertFalse(value in self.record["subfield_uuid"])
-
-    def test_mergeable_list_remove_tuple(self):
-        """Test tuple removal"""
-        value = (1, 2, 3, 4, 5)
-        self.record["subfield_uuid"].append(value)
-        self.record["subfield_uuid"].remove(value)
-        self.assertFalse(value in self.record["subfield_uuid"])
-
-    def test_mergeable_list_remove_missing(self):
-        """Test missing data rmeoval"""
-        self.assertRaises(ValueError, self.record["subfield_uuid"].remove,
-            "missing_data")
-
-    def test_mergeable_list_remove_last(self):
-        """Test that exception is raised when removing last item."""
-        self.record["subfield_uuid"] = MergeableList.from_list([1])
-        self.assertRaises(ValueError, self.record["subfield_uuid"].remove, 1)
-
-    def test_mergeable_list_pop_correct_index(self):
-        """Test the pop method when working with a correct index."""
-        value = [1, 2, 3, 4, 5]
-        self.record["subfield_uuid"] = MergeableList.from_list(value)
-        # test with negative index
-        popped_value = self.record["subfield_uuid"].pop(-2)
-        self.assertEqual(value[-2], popped_value)
-        # test with positive index
-        popped_value = self.record["subfield_uuid"].pop(1)
-        self.assertEqual(value[1], popped_value)
-
-    def test_mergeable_list_pop_wrong_index(self):
-        """Test pop when index is out or range."""
-        value = [1, 2, 3, 4, 5]
-        self.record["subfield_uuid"] = MergeableList.from_list(value)
-        self.assertRaises(IndexError, self.record["subfield_uuid"].pop,
-            len(value) * 2)
-
-    def test_mergeable_list_pop_no_index(self):
-        """Test pop without an index argument."""
-        value = [1, 2, 3, 4, 5]
-        self.record["subfield_uuid"] = MergeableList.from_list(value)
-        popped_value = self.record["subfield_uuid"].pop()
-        self.assertEqual(value[-1], popped_value)
-
-
-    def test_mergeable_list_pop_last(self):
-        """Test that exception is raised when poping last item"""
-        self.record["subfield_uuid"] = MergeableList.from_list([1])
-        self.assertRaises(ValueError, self.record["subfield_uuid"].pop, 0)
-
     def test_list(self):
         """Test assigning lists to a key results in mergeable lists."""
         rec = Record({'record_type': 'http://fnord.org/smorgasbord'})
@@ -275,7 +280,7 @@
     def test_mergeable_list(self):
         """Test assigning lists to a key results in mergeable lists."""
         rec = Record({'record_type': 'http://fnord.org/smorgasbord'})
-        rec['key'] = MergeableList.from_list([1, 2, 3, 4])
+        rec['key'] = MergeableList([1, 2, 3, 4])
         self.assert_(isinstance(rec['key'], MergeableList))
         self.assertEqual([1, 2, 3, 4], [value for value in rec['key']])
 
@@ -307,12 +312,10 @@
 
     def test_uuid_like_keys(self):
         """Test that appropriate errors are raised."""
-        # pylint: disable=W0212
-        keys = self.record["subfield_uuid"]._data.keys()
-        # pylint: enable=W0212
         self.assertRaises(
             IllegalKeyException,
-            self.record["subfield"].__setitem__, keys[0], 'stuff')
+            self.record["subfield"].__setitem__,
+            'd6d2c23b-279c-45c8-afb2-ec84ee7c81c3', 'stuff')
 
     def test_record_type(self):
         """Test the record_type property."""