Example #1
0
    def test_class_attribute(self):
        from dobbin.persistent import Persistent
        class Dummy(Persistent):
            dummy = 0

        from dobbin.tests import test_persistent as module
        module.Dummy = Dummy

        try:
            inst = self._get_root(Dummy)

            # local
            self.assertEqual(inst.dummy, 0)

            # shared
            import transaction
            transaction.commit()
            self.assertEqual(inst.dummy, 0)

            # local
            from dobbin.persistent import checkout
            checkout(inst)
            inst.dummy += 1
            self.assertEqual(inst.dummy, 1)

            # shared
            transaction.commit()
            self.assertEqual(inst.dummy, 1)
        finally:
            del module.Dummy
    def __init__(self):

        db = Database('database')

        if db .root is None:

            root = Persistent()
            root.list_of_users = []
            db.elect (root)
            transaction.commit()

            checkout(db.root)

            self.list_of_users = db.root.list_of_users

            # Creating a user default to make easy the development
            user = User('Fulano', '*****@*****.**', 'pwd', "uid")

            document = Document("My document", ".txt", "I think to myself... what a wonderful world!", "uid", user.folder.id)
            document.id = "did"
            user.folder.id = "fid"
            user.add_document(user.folder.id, document)

            db.root.list_of_users.append(user)
            db.root.list_of_users = self.list_of_users

            transaction.commit()

            checkout(db .root)

            self.list_of_users = db .root.list_of_users
        else:
            self.list_of_users = db.root.list_of_users
        super(UserRepository, self).__init__()
Example #3
0
    def test_pop(self):
        d = self._get_root()

        # local
        d['bar'] = 'foo'
        self.assertEqual(d.pop('bar'), 'foo')
        self.assertRaises(KeyError, d.pop, 'bar')
        self.assertEqual(d.pop('bar', 'boo'), 'boo')

        # shared
        transaction.commit()
        self.assertFalse('bar' in d)

        # local
        from dobbin.persistent import checkout
        checkout(d)
        d['bar'] = 'foo'

        # shared
        transaction.commit()

        # local
        checkout(d)
        self.assertEqual(d.pop('bar'), 'foo')
        self.assertFalse('bar' in d)

        # shared
        transaction.commit()
        self.assertFalse('bar' in d)
Example #4
0
    def test_clear(self):
        d = self._get_root()

        # local
        d['bar'] = 'foo'
        transaction.commit()

        from dobbin.persistent import checkout
        checkout(d)
        d.clear()
        self.assertEqual(d.get('bar'), None)

        # shared
        transaction.commit()
        self.assertEqual(d.get('bar'), None)

        # local
        checkout(d)
        d.clear()
        self.assertEqual(d.get('boo'), None)
        d['boo'] = 'foo'
        self.assertEqual(d.get('boo'), 'foo')

        # shared
        transaction.commit()
        self.assertEqual(d.get('boo'), 'foo')
Example #5
0
    def test_iteration(self):
        d = self._get_root()

        # local
        d['foo'] = 'bar'
        self.assertEqual(d.keys(), ['foo'])
        self.assertEqual(d.items(), [('foo', 'bar')])
        self.assertEqual(tuple(d), ('foo',))

        # shared
        transaction.commit()
        self.assertEqual(set(d.keys()), set(['foo']))
        self.assertEqual(set(d.items()), set((('foo', 'bar'),)))
        self.assertEqual(tuple(d), ('foo',))

        # local
        from dobbin.persistent import checkout
        checkout(d)
        d['bar'] = 'boo'
        self.assertEqual(sorted(d.keys()), ['bar', 'foo'])
        self.assertEqual(sorted(d.items()), [('bar', 'boo'), ('foo', 'bar')])
        self.assertEqual(tuple(sorted(d)), ('bar', 'foo',))

        # shared
        transaction.commit()
        self.assertEqual(sorted(d.keys()), ['bar', 'foo'])
        self.assertEqual(sorted(d.items()), [('bar', 'boo'), ('foo', 'bar')])
        self.assertEqual(tuple(sorted(d)), ('bar', 'foo',))
Example #6
0
 def benchmark():
     transaction.begin()
     item = items.pop()
     checkout(item)
     item.name1 = 'Bob'
     item.name2 = 'Bill'
     item.ref = item
     transaction.commit()
Example #7
0
 def benchmark():
     transaction.begin()
     items = [Persistent() for i in range(1000)]
     for item in items:
         item.name = 'Bob'
     checkout(root)
     root.items = items
     transaction.commit()
Example #8
0
 def run():
     checkout(obj)
     obj.name = 'Bob'
     flag.acquire()
     try:
         transaction.commit()
     finally:
         flag.release()
Example #9
0
    def test_integrity(self):
        obj = self._get_root()
        thread = self._get_thread(obj)

        from dobbin.persistent import checkout
        checkout(obj)

        self._flag.release()
        thread.join()

        self.assertRaises(AttributeError, getattr, obj, 'name')
Example #10
0
    def add(self, obj):
        """Add an object to the database.

        Note that the recommended way to add objects is through the
        root object graph.
        """

        if obj._p_jar is None:
            obj._p_jar = self
        elif obj._p_jar is self:
            raise RuntimeError("Object already added to the database.")
        else:
            raise InvalidObjectReference(obj)

        checkout(obj)
Example #11
0
    def test_write_conflict(self):
        obj = self._get_root()
        thread = self._get_thread(obj)

        from dobbin.persistent import checkout
        checkout(obj)
        obj.name = 'Bill'

        self._flag.release()
        thread.join()

        from dobbin.exc import WriteConflictError
        self.assertRaises(WriteConflictError, transaction.commit)
        transaction.abort()

        self.assertEqual(obj.name, 'Bob')
Example #12
0
    def test_read_conflict(self):
        from copy import copy
        obj = self._get_root()

        new_db = copy(obj._p_jar)
        thread = self._get_thread(new_db.root)

        from dobbin.persistent import checkout
        checkout(obj)
        obj.name = 'Bill'

        self._flag.release()
        thread.join()

        from dobbin.exc import ReadConflictError
        self.assertRaises(ReadConflictError, transaction.commit)
        transaction.abort()

        self.assertEqual(obj.name, 'Bob')
Example #13
0
    def test_assignment(self):
        d = self._get_root()

        # local
        d['foo'] = 'bar'
        self.assertEqual(d['foo'], 'bar')

        # shared
        transaction.commit()
        self.assertEqual(d['foo'], 'bar')

        # local
        from dobbin.persistent import checkout
        checkout(d)
        d['bar'] = 'boo'
        self.assertEqual(d['foo'], 'bar')
        self.assertEqual(d['bar'], 'boo')

        # shared
        transaction.commit()
        self.assertEqual(d['foo'], 'bar')
        self.assertEqual(d['bar'], 'boo')
Example #14
0
    def test_custom_setattr(self):
        marker = []
        from dobbin.persistent import Persistent
        class Dummy(Persistent):
            def __setattr__(self, key, value):
                marker.append(key)
                super(Dummy, self).__setattr__(key, value)

        from dobbin.tests import test_persistent as module
        module.Dummy = Dummy

        try:
            inst = self._get_root(Dummy)

            # local
            inst.dummy = 1
            self.assertEqual(inst.dummy, 1)
            self.assertEqual(marker[-1], 'dummy')
            del marker[:]

            # shared
            import transaction
            transaction.commit()
            self.assertEqual(inst.dummy, 1)

            # local
            from dobbin.persistent import checkout
            checkout(inst)
            inst.dummy += 1
            self.assertEqual(inst.dummy, 2)
            self.assertEqual(marker[-1], 'dummy')
            del marker[:]

            # shared
            transaction.commit()
            self.assertEqual(inst.dummy, 2)
        finally:
            del module.Dummy
    def save(self):

        db = Database('database')
        checkout(db.root)
        db.root.list_of_users = self.list_of_users
        transaction.commit()
Example #16
0
 def benchmark():
     transaction.begin()
     checkout(root)
     root[None] = "abc"
     transaction.commit()