first working implementation

4 files changed, 184 insertions, 149 deletions

diff --git a/tests/basic_api.txt b/tests/basic_api.txt
deleted file mode 100644
index 23ecc9c..0000000
--- a/tests/basic_api.txt
+++ /dev/null
@@ -1,115 +0,0 @@
->>> import os
->>> import tempfile
->>> import time
-
-Define some helper functions
->>> def test_unique(items) :
-...     return not [True for e in items if items.count(e) > 1]
-
-
-Connect to datastore using DBus and wait for it to get ready:
->>> import dbus
->>> DS_DBUS_SERVICE = "org.silbe.GDataStore"
->>> DS_DBUS_INTERFACE = "org.silbe.GDataStore"
->>> DS_DBUS_PATH = "/org/silbe/GDataStore"
->>> bus = dbus.SessionBus()
->>> ds = dbus.Interface(bus.get_object(DS_DBUS_SERVICE, DS_DBUS_PATH), DS_DBUS_INTERFACE)
-
-
-Make sure we're starting from an empty datastore:
->>> assert ds.find({}, [], byte_arrays=True) == ([], 0)
-
-
-Create something to play with:
->>> o1_uid = ds.create({'title': 'DS test object 1', 'mime_type': 'text/plain', 'activity': 'org.silbe.DataStoreTest1'}, '', False)
->>> assert isinstance(o1_uid, basestring)
->>> o2_uid = ds.create({'title': 'DS test object 2', 'mime_type': 'text/plain', 'activity': 'org.silbe.DataStoreTest2'}, '', False)
->>> assert isinstance(o2_uid, basestring)
->>> o3_uid = ds.create({'title': 'DS test object 3', 'mime_type': 'text/plain', 'activity': 'org.silbe.DataStoreTest2'}, '', False)
->>> assert isinstance(o3_uid, basestring)
->>> assert test_unique([o1_uid, o2_uid, o3_uid])
-
-
-Check everything is there:
->>> sorted(ds.find({}, ['title', 'activity'], byte_arrays=True)[0])
-[dbus.Dictionary({dbus.String(u'title'): dbus.ByteArray('DS test object 1', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest1', variant_level=1)}, signature=dbus.Signature('sv')), dbus.Dictionary({dbus.String(u'title'): dbus.ByteArray('DS test object 2', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest2', variant_level=1)}, signature=dbus.Signature('sv')), dbus.Dictionary({dbus.String(u'title'): dbus.ByteArray('DS test object 3', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest2', variant_level=1)}, signature=dbus.Signature('sv'))]
->>> ds.get_filename(o1_uid, byte_arrays=True)
-dbus.String(u'')
->>> ds.get_filename(o2_uid, byte_arrays=True)
-dbus.String(u'')
->>> ds.get_filename(o3_uid, byte_arrays=True)
-dbus.String(u'')
-
-
-
-Test get_uniquevaluesfor().
->>> sorted(ds.get_uniquevaluesfor('activity', {}))
-[dbus.String(u'org.silbe.DataStoreTest1'), dbus.String(u'org.silbe.DataStoreTest2')]
-
-
-Change some entries:
->>> ds.update(o1_uid, {'title': 'DS test object 1 updated', 'mime_type': 'text/plain', 'activity': 'org.silbe.DataStoreTest1', 'tags': 'foo'}, '', False)
->>> ds.update(o2_uid, {'title': 'DS test object 2', 'mime_type': 'text/plain', 'activity': 'org.silbe.DataStoreTest1', 'tags': 'bar baz'}, '', False)
->>> ds.update(o3_uid, {'title': 'DS test object 2', 'mime_type': 'text/html', 'activity': 'org.silbe.DataStoreTest3', 'timestamp': 10000}, '', False)
->>> sorted(ds.find({}, ['title', 'activity'], byte_arrays=True)[0])
-[dbus.Dictionary({dbus.String(u'title'): dbus.ByteArray('DS test object 1 updated', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest1', variant_level=1)}, signature=dbus.Signature('sv')), dbus.Dictionary({dbus.String(u'title'): dbus.ByteArray('DS test object 2', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest1', variant_level=1)}, signature=dbus.Signature('sv')), dbus.Dictionary({dbus.String(u'title'): dbus.ByteArray('DS test object 2', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest3', variant_level=1)}, signature=dbus.Signature('sv'))]
-
-
-Retrieve metadata for a single entry, ignoring variable data:
->>> d=dict(ds.get_properties(o3_uid, byte_arrays=True))
->>> del d['uid'], d['timestamp']
->>> d
-{dbus.String(u'title'): dbus.ByteArray('DS test object 2', variant_level=1), dbus.String(u'mime_type'): dbus.ByteArray('text/html', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest3', variant_level=1)}
-
-
-Find entries using "known" metadata:
->>> sorted(ds.find({'mime_type': ['text/plain']}, ['title', 'activity', 'mime_type', 'tags'], byte_arrays=True)[0])
-[dbus.Dictionary({dbus.String(u'title'): dbus.ByteArray('DS test object 2', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest1', variant_level=1), dbus.String(u'mime_type'): dbus.ByteArray('text/plain', variant_level=1), dbus.String(u'tags'): dbus.ByteArray('bar baz', variant_level=1)}, signature=dbus.Signature('sv')), dbus.Dictionary({dbus.String(u'title'): dbus.ByteArray('DS test object 1 updated', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest1', variant_level=1), dbus.String(u'mime_type'): dbus.ByteArray('text/plain', variant_level=1), dbus.String(u'tags'): dbus.ByteArray('foo', variant_level=1)}, signature=dbus.Signature('sv'))]
->>> sorted(ds.find({'mime_type': ['text/html']}, ['title', 'activity', 'mime_type', 'tags'], byte_arrays=True)[0])
-[dbus.Dictionary({dbus.String(u'title'): dbus.ByteArray('DS test object 2', variant_level=1), dbus.String(u'mime_type'): dbus.ByteArray('text/html', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest3', variant_level=1)}, signature=dbus.Signature('sv'))]
->>> sorted(ds.find({'uid': o3_uid}, ['title', 'activity', 'mime_type'], byte_arrays=True)[0])
-[dbus.Dictionary({dbus.String(u'title'): dbus.ByteArray('DS test object 2', variant_level=1), dbus.String(u'mime_type'): dbus.ByteArray('text/html', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest3', variant_level=1)}, signature=dbus.Signature('sv'))]
->>> sorted(ds.find({'timestamp': (9000, 11000)}, ['title', 'activity', 'mime_type'], byte_arrays=True)[0])
-[dbus.Dictionary({dbus.String(u'title'): dbus.ByteArray('DS test object 2', variant_level=1), dbus.String(u'mime_type'): dbus.ByteArray('text/html', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest3', variant_level=1)}, signature=dbus.Signature('sv'))]
-
-Find entries using "unknown" metadata (=> returns all entries):
->>> sorted(ds.find({'title': 'DS test object 2'}, ['title', 'activity', 'mime_type', 'tags'], byte_arrays=True)[0])
-[dbus.Dictionary({dbus.String(u'title'): dbus.ByteArray('DS test object 2', variant_level=1), dbus.String(u'mime_type'): dbus.ByteArray('text/html', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest3', variant_level=1)}, signature=dbus.Signature('sv')), dbus.Dictionary({dbus.String(u'title'): dbus.ByteArray('DS test object 2', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest1', variant_level=1), dbus.String(u'mime_type'): dbus.ByteArray('text/plain', variant_level=1), dbus.String(u'tags'): dbus.ByteArray('bar baz', variant_level=1)}, signature=dbus.Signature('sv')), dbus.Dictionary({dbus.String(u'title'): dbus.ByteArray('DS test object 1 updated', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest1', variant_level=1), dbus.String(u'mime_type'): dbus.ByteArray('text/plain', variant_level=1), dbus.String(u'tags'): dbus.ByteArray('foo', variant_level=1)}, signature=dbus.Signature('sv'))]
-
-Specify a sort order:
->>> ds.find({'order_by': ['+title']}, ['title', 'activity'], byte_arrays=True)[0]
-dbus.Array([dbus.Dictionary({dbus.String(u'title'): dbus.ByteArray('DS test object 2', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest1', variant_level=1)}, signature=dbus.Signature('sv')), dbus.Dictionary({dbus.String(u'title'): dbus.ByteArray('DS test object 2', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest3', variant_level=1)}, signature=dbus.Signature('sv')), dbus.Dictionary({dbus.String(u'title'): dbus.ByteArray('DS test object 1 updated', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest1', variant_level=1)}, signature=dbus.Signature('sv'))], signature=dbus.Signature('a{sv}'))
->>> ds.find({'order_by': ['-title']}, ['title', 'activity'], byte_arrays=True)[0]
-dbus.Array([dbus.Dictionary({dbus.String(u'title'): dbus.ByteArray('DS test object 1 updated', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest1', variant_level=1)}, signature=dbus.Signature('sv')), dbus.Dictionary({dbus.String(u'title'): dbus.ByteArray('DS test object 2', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest1', variant_level=1)}, signature=dbus.Signature('sv')), dbus.Dictionary({dbus.String(u'title'): dbus.ByteArray('DS test object 2', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest3', variant_level=1)}, signature=dbus.Signature('sv'))], signature=dbus.Signature('a{sv}'))
-
-Delete an entry:
->>> ds.delete(o1_uid)
->>> sorted(ds.find({}, ['title', 'activity'], byte_arrays=True)[0])
-[dbus.Dictionary({dbus.String(u'title'): dbus.ByteArray('DS test object 2', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest1', variant_level=1)}, signature=dbus.Signature('sv')), dbus.Dictionary({dbus.String(u'title'): dbus.ByteArray('DS test object 2', variant_level=1), dbus.String(u'activity'): dbus.ByteArray('org.silbe.DataStoreTest3', variant_level=1)}, signature=dbus.Signature('sv'))]
-
-
-Create an entry with content:
->>> dog_content = 'The quick brown dog jumped over the lazy fox.'
->>> dog_props = {'title': 'dog/fox story', 'mime_type': 'text/plain'}
->>> dog_file = tempfile.NamedTemporaryFile()
->>> dog_file.write(dog_content)
->>> dog_file.flush()
->>> dog_uid = ds.create(dog_props, dog_file.name, False)
-
-Retrieve and verify the entry with content:
->>> dog_retrieved = ds.get_filename(dog_uid)
->>> assert(file(dog_retrieved).read() == dog_content)
->>> os.remove(dog_retrieved)
-
-Update the entry content:
->>> dog_content = 'The quick brown fox jumped over the lazy dog.'
->>> dog_file.seek(0)
->>> dog_file.write(dog_content)
->>> dog_file.flush()
->>> ds.update(dog_uid, dog_props, dog_file.name, False)
-
-Verify updated content:
->>> dog_retrieved = ds.get_filename(dog_uid)
->>> assert(file(dog_retrieved).read() == dog_content)
->>> os.remove(dog_retrieved)
->>> dog_file.close()
diff --git a/tests/runalltests.py b/tests/runalltests.py
index f539746..c39aa12 100755
--- a/tests/runalltests.py
+++ b/tests/runalltests.py
@@ -32,9 +32,10 @@ logging.basicConfig(level=logging.WARN,
 
 
 DOCTESTS = [
-    'basic_api.txt',
+    'sugar_api_v2.txt',
 ]
-DOCTEST_OPTIONS = doctest.ELLIPSIS | doctest.REPORT_ONLY_FIRST_FAILURE | REPORT_UDIFF
+DOCTEST_OPTIONS = (doctest.ELLIPSIS | doctest.REPORT_ONLY_FIRST_FAILURE |
+                   doctest.REPORT_UDIFF)
 
 DS_DBUS_SERVICE = 'org.silbe.GDataStore'
 DS_DBUS_INTERFACE = 'org.silbe.GDataStore'
@@ -70,12 +71,12 @@ def setup():
     environment['PATH'] = os.path.join(basedir, 'bin')+':'+os.environ['PATH']
 
     servicedir = os.path.join(environment['HOME'], 'dbus-1', 'services')
-    servicepath = os.path.join(servicedir, 'org.silbe.GDataStore.service')
+    servicepath = os.path.join(servicedir, 'org.laptop.sugar.DataStore.service')
     os.makedirs(servicedir)
     servicefile = file(servicepath, 'w')
     servicefile.write("""
         [D-BUS Service]
-        Name = org.silbe.GDataStore
+        Name = org.laptop.sugar.DataStore
         Exec = %s/bin/gdatastore-service
         """.replace('        ', '') % (basedir, ))
     servicefile.close()
@@ -174,7 +175,7 @@ class TestSuiteWrapper(unittest.TestCase):
 
     def tearDown(self):
         self._kill_data_store()
-        self._clean_data_store()
+        #self._clean_data_store()
 
     def _kill_data_store(self):
         pgrep = subprocess.Popen(['pgrep', '-g', os.environ['DBUS_PID'],
@@ -197,7 +198,7 @@ class TestSuiteWrapper(unittest.TestCase):
             self._loop.quit()
 
     def _clean_data_store(self):
-        shutil.rmtree(os.path.expanduser('~/.gdatastore'))
+        shutil.rmtree(os.path.expanduser('~/.gdatastore/git'))
 
 
 class TimedTestResult(unittest._TextTestResult):
diff --git a/tests/sugar_api_v2.txt b/tests/sugar_api_v2.txt
new file mode 100644
index 0000000..a2846eb
--- /dev/null
+++ b/tests/sugar_api_v2.txt
@@ -0,0 +1,134 @@
+>>> import os
+>>> import tempfile
+>>> import time
+
+Define some helper functions
+>>> def test_unique(items):
+...     return not [True for e in items if items.count(e) > 1]
+>>> def to_native(value):
+...     if isinstance(value, list):
+...         return [to_native(e) for e in value]
+...     elif isinstance(value, dict):
+...         return dict([(to_native(k), to_native(v)) for k, v in value.items()])
+...     elif isinstance(value, unicode):
+...         return unicode(value)
+...     elif isinstance(value, str):
+...         return str(value)
+...     return value
+
+
+Connect to datastore using DBus and wait for it to get ready:
+>>> import dbus
+>>> DS_DBUS_SERVICE = 'org.laptop.sugar.DataStore'
+>>> DS_DBUS_INTERFACE = 'org.laptop.sugar.DataStore'
+>>> DS_DBUS_PATH = '/org/laptop/sugar/DataStore'
+>>> bus = dbus.SessionBus()
+>>> ds = dbus.Interface(bus.get_object(DS_DBUS_SERVICE, DS_DBUS_PATH), DS_DBUS_INTERFACE)
+
+
+Make sure we're starting from an empty datastore:
+>>> assert ds.find({}, [], byte_arrays=True) == ([], 0)
+
+
+Create something to play with:
+>>> o1_uid = ds.create({'title': 'DS test object 1', 'mime_type': 'text/plain', 'activity': 'org.sugarlabs.DataStoreTest1'}, '', False)
+>>> assert isinstance(o1_uid, basestring)
+>>> o2_uid = ds.create({'title': 'DS test object 2', 'mime_type': 'text/plain', 'activity': 'org.sugarlabs.DataStoreTest2'}, '', False)
+>>> assert isinstance(o2_uid, basestring)
+>>> o3_uid = ds.create({'title': 'DS test object 3', 'mime_type': 'text/plain', 'activity': 'org.sugarlabs.DataStoreTest2'}, '', False)
+>>> assert isinstance(o3_uid, basestring)
+>>> assert test_unique([o1_uid, o2_uid, o3_uid])
+
+
+Check everything is there:
+>>> assert sorted(to_native(ds.find({}, ['title', 'activity'], byte_arrays=True)[0])) == \
+... [{u'title': 'DS test object 1', u'activity': 'org.sugarlabs.DataStoreTest1'},
+...  {u'title': 'DS test object 2', u'activity': 'org.sugarlabs.DataStoreTest2'},
+...  {u'title': 'DS test object 3', u'activity': 'org.sugarlabs.DataStoreTest2'}]
+>>> ds.get_filename(o1_uid, byte_arrays=True)
+dbus.String(u'')
+>>> ds.get_filename(o2_uid, byte_arrays=True)
+dbus.String(u'')
+>>> ds.get_filename(o3_uid, byte_arrays=True)
+dbus.String(u'')
+
+
+
+Test get_uniquevaluesfor().
+>>> sorted(ds.get_uniquevaluesfor('activity', {}))
+[dbus.String(u'org.sugarlabs.DataStoreTest1'), dbus.String(u'org.sugarlabs.DataStoreTest2')]
+
+
+Change some entries:
+>>> ds.update(o1_uid, {'title': 'DS test object 1 updated', 'mime_type': 'text/plain', 'activity': 'org.sugarlabs.DataStoreTest1', 'tags': 'foo'}, '', False)
+>>> ds.update(o2_uid, {'title': 'DS test object 2', 'mime_type': 'text/plain', 'activity': 'org.sugarlabs.DataStoreTest1', 'tags': 'bar baz'}, '', False)
+>>> ds.update(o3_uid, {'title': 'DS test object 2', 'mime_type': 'text/html', 'activity': 'org.sugarlabs.DataStoreTest3', 'timestamp': 10000}, '', False)
+>>> assert sorted(to_native(ds.find({}, ['title', 'activity'], byte_arrays=True)[0])) == \
+... [{u'activity': 'org.sugarlabs.DataStoreTest1', u'title': 'DS test object 1 updated'},
+...  {u'activity': 'org.sugarlabs.DataStoreTest1', u'title': 'DS test object 2'},
+...  {u'activity': 'org.sugarlabs.DataStoreTest3', u'title': 'DS test object 2'}]
+
+Retrieve metadata for a single entry, ignoring variable data:
+>>> d=dict(ds.get_properties(o3_uid, byte_arrays=True))
+>>> del d['uid'], d['timestamp'], d['creation_time']
+>>> assert to_native(d) == {u'title': 'DS test object 2', u'mime_type': 'text/html', u'activity': 'org.sugarlabs.DataStoreTest3'}
+
+
+Find entries using "standard" metadata:
+>>> assert sorted(to_native(ds.find({'mime_type': ['text/plain']}, ['title', 'activity', 'mime_type', 'tags'], byte_arrays=True)[0])) == \
+... [{u'title': 'DS test object 2', u'activity': 'org.sugarlabs.DataStoreTest1', u'mime_type': 'text/plain', u'tags': 'bar baz'},
+...  {u'title': 'DS test object 1 updated', u'activity': 'org.sugarlabs.DataStoreTest1', u'mime_type': 'text/plain', u'tags': 'foo'}]
+>>> assert sorted(to_native(ds.find({'mime_type': ['text/html']}, ['title', 'activity', 'mime_type', 'tags'], byte_arrays=True)[0])) == \
+... [{u'title': 'DS test object 2', u'mime_type': 'text/html', u'activity': 'org.sugarlabs.DataStoreTest3'}]
+>>> assert sorted(to_native(ds.find({'uid': o3_uid}, ['title', 'activity', 'mime_type'], byte_arrays=True)[0])) == \
+... [{u'title': 'DS test object 2', u'mime_type': 'text/html', u'activity': 'org.sugarlabs.DataStoreTest3'}]
+>>> assert sorted(to_native(ds.find({'timestamp': (9000, 11000)}, ['title', 'activity', 'mime_type'], byte_arrays=True)[0])) == \
+... [{u'title': 'DS test object 2', u'mime_type': 'text/html', u'activity': 'org.sugarlabs.DataStoreTest3'}]
+
+Find entries using "non-standard" metadata (only works with dict-based queries or prefixed Xapian query strings):
+>>> assert sorted(to_native(ds.find({'title': 'DS test object 2'}, ['title', 'activity', 'mime_type', 'tags'], byte_arrays=True)[0])) == \
+... [{u'title': 'DS test object 2', u'mime_type': 'text/html', u'activity': 'org.sugarlabs.DataStoreTest3'},
+...  {u'title': 'DS test object 2', u'activity': 'org.sugarlabs.DataStoreTest1', u'mime_type': 'text/plain', u'tags': 'bar baz'}]
+
+You can specify a (primary) sort order. Please note that the secondary sort order is undefined / implementation-dependent.
+>>> assert to_native(ds.find({'order_by': ['+title']}, ['title', 'activity'], byte_arrays=True)[0]) == \
+... [{u'activity': 'org.sugarlabs.DataStoreTest3', u'title': 'DS test object 2'},
+...  {u'activity': 'org.sugarlabs.DataStoreTest1', u'title': 'DS test object 2'},
+...  {u'activity': 'org.sugarlabs.DataStoreTest1', u'title': 'DS test object 1 updated'}]
+>>> assert to_native(ds.find({'order_by': ['-title']}, ['title', 'activity'], byte_arrays=True)[0]) == \
+... [{u'activity': 'org.sugarlabs.DataStoreTest1', u'title': 'DS test object 1 updated'},
+...  {u'activity': 'org.sugarlabs.DataStoreTest1', u'title': 'DS test object 2'},
+...  {u'activity': 'org.sugarlabs.DataStoreTest3', u'title': 'DS test object 2'}]
+
+Delete an entry:
+>>> ds.delete(o1_uid)
+>>> assert sorted(to_native(ds.find({}, ['title', 'activity'], byte_arrays=True)[0])) == \
+... [{u'title': 'DS test object 2', u'activity': 'org.sugarlabs.DataStoreTest1'},
+...  {u'title': 'DS test object 2', u'activity': 'org.sugarlabs.DataStoreTest3'}]
+
+
+Create an entry with content:
+>>> dog_content = 'The quick brown dog jumped over the lazy fox.'
+>>> dog_props = {'title': 'dog/fox story', 'mime_type': 'text/plain'}
+>>> dog_file = tempfile.NamedTemporaryFile()
+>>> dog_file.write(dog_content)
+>>> dog_file.flush()
+>>> dog_uid = ds.create(dog_props, dog_file.name, False)
+
+Retrieve and verify the entry with content:
+>>> dog_retrieved = ds.get_filename(dog_uid)
+>>> assert(file(dog_retrieved).read() == dog_content)
+>>> os.remove(dog_retrieved)
+
+Update the entry content:
+>>> dog_content = 'The quick brown fox jumped over the lazy dog.'
+>>> dog_file.seek(0)
+>>> dog_file.write(dog_content)
+>>> dog_file.flush()
+>>> ds.update(dog_uid, dog_props, dog_file.name, False)
+
+Verify updated content:
+>>> dog_retrieved = ds.get_filename(dog_uid)
+>>> assert(file(dog_retrieved).read() == dog_content)
+>>> os.remove(dog_retrieved)
+>>> dog_file.close()
diff --git a/tests/test_massops.py b/tests/test_massops.py
index ec3bef6..b14d7ac 100644
--- a/tests/test_massops.py
+++ b/tests/test_massops.py
@@ -9,12 +9,17 @@ import time
 import unittest
 
 
-DS_DBUS_SERVICE = 'org.silbe.GDataStore'
-DS_DBUS_INTERFACE = 'org.silbe.GDataStore'
-DS_DBUS_PATH = '/org/silbe/GDataStore'
+DS_DBUS_SERVICE = 'org.laptop.sugar.DataStore'
+DS_DBUS_INTERFACE = 'org.laptop.sugar.DataStore'
+DS_DBUS_PATH = '/org/laptop/sugar/DataStore'
 NUM_RUNS = int(os.environ.get('MASSOPS_RUNS', '100'))
 IGNORE_PROPERTIES = [
+    'checksum',
+    'creation_time',
     'number',
+    'timestamp',
+    'uid',
+    'version_id',
 ]
 
 
@@ -29,17 +34,17 @@ class MassOpsTestCase(unittest.TestCase):
     """Large number of operations intended for measuring performance."""
 
     def setUp(self):
-        # pylint: disable-msg=C0103
+        # pylint: disable=C0103
         self._bus = dbus.SessionBus()
         self._datastore = dbus.Interface(self._bus.get_object(DS_DBUS_SERVICE,
-            DS_DBUS_PATH), DS_DBUS_INTERFACE)
+                                         DS_DBUS_PATH), DS_DBUS_INTERFACE)
 
     _create_properties = {
         'title': 'DS test object',
         'mime_type': 'text/plain',
-        'activity': 'org.silbe.GDataStoreTest1',
+        'activity': 'org.sugarlabs.DataStoreTest1',
     }
-    _create_content = 'Foo bar\n'*1000
+    _create_content = 'Foo bar\n' * 1000
 
     def test_create(self):
         """Run create() lots of times to create new objects."""
@@ -57,17 +62,18 @@ class MassOpsTestCase(unittest.TestCase):
     def test_find_all(self):
         """Run find() to list all entries."""
         entries, total_count = self._datastore.find({}, ['number'],
-            byte_arrays=True)
+                                                    byte_arrays=True)
         self.assertEquals(total_count, NUM_RUNS)
         self.assertEquals(total_count, len(entries))
         for position, entry in enumerate(entries):
-            self.assertEquals(int(entry['number']), NUM_RUNS-position-1)
+            self.assertEquals(int(entry['number']), NUM_RUNS - position - 1)
 
     @repeat
     def test_find_all_reverse_time(self):
         """Run find() to list all entries in reverse chronological order."""
-        entries, total_count = self._datastore.find({'order_by':
-            ['-timestamp']}, ['number'], byte_arrays=True)
+        entries, total_count = \
+            self._datastore.find({'order_by': ['-timestamp']}, ['number'],
+                                 byte_arrays=True)
         self.assertEquals(total_count, NUM_RUNS)
         self.assertEquals(total_count, len(entries))
         for position, entry in enumerate(entries):
@@ -76,16 +82,18 @@ class MassOpsTestCase(unittest.TestCase):
     @repeat
     def test_find_all_title(self):
         """Run find() to list all entries ordered by title."""
-        entries, total_count = self._datastore.find({'order_by':
-            ['+title']}, ['tree_id'], byte_arrays=True)
+        entries, total_count = \
+            self._datastore.find({'order_by': ['+title']}, ['tree_id'],
+                                 byte_arrays=True)
         self.assertEquals(total_count, NUM_RUNS)
         self.assertEquals(total_count, len(entries))
 
     @repeat
     def test_find_all_reverse_title(self):
         """Run find() to list all entries ordered by title (reversed)."""
-        entries, total_count = self._datastore.find({'order_by':
-            ['-title']}, ['tree_id'], byte_arrays=True)
+        entries, total_count = \
+            self._datastore.find({'order_by': ['-title']}, ['tree_id'],
+                                 byte_arrays=True)
         self.assertEquals(total_count, NUM_RUNS)
         self.assertEquals(total_count, len(entries))
 
@@ -94,21 +102,24 @@ class MassOpsTestCase(unittest.TestCase):
         """Run find() to list all entries in small chunks."""
         chunk_size = 30
         for chunk_start in range(0, NUM_RUNS, 30):
-            entries, total_count = self._datastore.find({
-                'offset': chunk_start, 'limit': chunk_size},
-                ['number'], byte_arrays=True)
+            entries, total_count = \
+                self._datastore.find({'offset': chunk_start,
+                                      'limit': chunk_size}, ['number'],
+                                     byte_arrays=True)
             self.assertEquals(len(entries),
-                min(chunk_size, NUM_RUNS-chunk_start))
+                              min(chunk_size, NUM_RUNS - chunk_start))
             self.assertEquals(total_count, NUM_RUNS)
             for position, entry in enumerate(entries):
                 self.assertEquals(int(entry['number']),
-                    NUM_RUNS-(chunk_start+position)-1)
+                                  NUM_RUNS - (chunk_start + position) - 1)
 
     def test_get_properties(self):
         """Run get_properties() on all entries and verify result."""
         for entry in self._datastore.find({}, ['uid'], byte_arrays=True)[0]:
-            properties = self._datastore.get_properties(entry['uid'],
-                byte_arrays=True)
+            properties = \
+                self._datastore.get_properties(entry['uid'], byte_arrays=True)
+            self.assertEquals(properties.pop('filesize'),
+                              str(len(self._create_content)))
             self._filter_properties(properties)
             self.assertEquals(properties, self._create_properties)
 
@@ -116,7 +127,7 @@ class MassOpsTestCase(unittest.TestCase):
         """Run get_filename() on all entries and verify content."""
         for entry in self._datastore.find({}, ['uid'], byte_arrays=True)[0]:
             filename = self._datastore.get_filename(entry['uid'],
-                byte_arrays=True)
+                                                    byte_arrays=True)
             try:
                 self.assertEquals(file(filename).read(), self._create_content)
             finally:
@@ -125,9 +136,9 @@ class MassOpsTestCase(unittest.TestCase):
     _update_properties = {
         'title': 'DS test object (updated)',
         'mime_type': 'text/plain',
-        'activity': 'org.silbe.GDataStoreTest1',
+        'activity': 'org.sugarlabs.DataStoreTest1',
     }
-    _update_content = 'Foo bar baz\n'*1000
+    _update_content = 'Foo bar baz\n' * 1000
 
     def test_update(self):
         """Update the content of all existing entries"""
@@ -136,13 +147,17 @@ class MassOpsTestCase(unittest.TestCase):
         content_file.flush()
         for entry in self._datastore.find({}, ['uid'], byte_arrays=True)[0]:
             self._datastore.update(entry['uid'], self._update_properties,
-                content_file.name, False)
+                                   content_file.name, False)
 
     def test_update_verify(self):
-        """Verify test_update() has changed content and metadata of all entries."""
+        """Verify test_update() has changed content and metadata of all
+        entries.
+        """
         for entry in self._datastore.find({}, [], byte_arrays=True)[0]:
             filename = self._datastore.get_filename(entry['uid'],
-                byte_arrays=True)
+                                                    byte_arrays=True)
+            self.assertEquals(entry.pop('filesize'),
+                              str(len(self._update_content)))
             self._filter_properties(entry)
             try:
                 self.assertEquals(entry, self._update_properties)