Merge lp:~jameinel/u1db/resolve_doc into lp:u1db

[John A Meinel]

Change resolve_doc to take a Document and a list of revisions that it supersedes. Then mutate the doc directly rather than returning another doc.

This also moves the tests from test_sync into test_backends.

[Samuele Pedroni (pedronis)]

looks good, test_resolve_doc was moved over twice though!

review: Approve

[lp:~jameinel/u1db/resolve_doc]

126. By John A Meinel on 2011-11-25

Remove the duplicate test.

=== modified file 'u1db/__init__.py'
--- u1db/__init__.py	2011-11-23 13:46:56 +0000
+++ u1db/__init__.py	2011-11-25 15:43:24 +0000
@@ -187,8 +187,9 @@
         """
         raise NotImplementedError(self.get_doc_conflicts)
 
-    def resolve_doc(self, doc_id, doc, conflicted_doc_revs):
+    def resolve_doc(self, doc, conflicted_doc_revs):
         """Mark a document as no longer conflicted.
+
         We take the list of revisions that the client knows about that it is
         superseding. This may be a different list from the actual current
         conflicts, in which case only those are removed as conflicted.  This
@@ -196,7 +197,11 @@
         supplied information. (sync could have happened in the background from
         the time you GET_DOC_CONFLICTS until the point where you RESOLVE)
 
-        :return: (new_rev, still_conflicted)
+        :param doc: A Document with the new content to be inserted.
+        :param conflicted_doc_revs: A list of revisions that the new content
+            supersedes.
+        :return: None, doc will be updated with the new revision and
+            has_conflict flags.
         """
         raise NotImplementedError(self.resolve_doc)
 

=== modified file 'u1db/backends/inmemory.py'
--- u1db/backends/inmemory.py	2011-11-23 12:39:32 +0000
+++ u1db/backends/inmemory.py	2011-11-25 15:43:24 +0000
@@ -110,25 +110,27 @@
         result.extend(self._conflicts[doc_id])
         return result
 
-    def resolve_doc(self, doc_id, doc, conflicted_doc_revs):
-        cur_rev, cur_doc = self._docs[doc_id]
+    def resolve_doc(self, doc, conflicted_doc_revs):
+        cur_rev, cur_content = self._docs[doc.doc_id]
         new_rev = self._ensure_maximal_rev(cur_rev, conflicted_doc_revs)
         superseded_revs = set(conflicted_doc_revs)
         remaining_conflicts = []
-        cur_conflicts = self._conflicts[doc_id]
+        cur_conflicts = self._conflicts[doc.doc_id]
         for c_rev, c_doc in cur_conflicts:
             if c_rev in superseded_revs:
                 continue
             remaining_conflicts.append((c_rev, c_doc))
         if cur_rev in superseded_revs:
-            self._put_and_update_indexes(doc_id, cur_doc, new_rev, doc)
+            self._put_and_update_indexes(doc.doc_id, cur_content, new_rev,
+                                         doc.content)
         else:
-            remaining_conflicts.append((new_rev, doc))
+            remaining_conflicts.append((new_rev, doc.content))
         if not remaining_conflicts:
-            del self._conflicts[doc_id]
+            del self._conflicts[doc.doc_id]
         else:
-            self._conflicts[doc_id] = remaining_conflicts
-        return new_rev, bool(remaining_conflicts)
+            self._conflicts[doc.doc_id] = remaining_conflicts
+        doc.rev = new_rev
+        doc.has_conflicts = bool(remaining_conflicts)
 
     def delete_doc(self, doc_id, doc_rev):
         if doc_id not in self._docs:

=== modified file 'u1db/backends/sqlite_backend.py'
--- u1db/backends/sqlite_backend.py	2011-11-23 13:46:56 +0000
+++ u1db/backends/sqlite_backend.py	2011-11-25 15:43:24 +0000
@@ -381,22 +381,23 @@
             self._put_and_update_indexes(doc.doc_id, my_doc.content, doc.rev,
                                          doc.content)
 
-    def resolve_doc(self, doc_id, doc, conflicted_doc_revs):
+    def resolve_doc(self, doc, conflicted_doc_revs):
         with self._db_handle:
-            cur_doc = self._get_doc(doc_id)
+            cur_doc = self._get_doc(doc.doc_id)
             new_rev = self._ensure_maximal_rev(cur_doc.rev, conflicted_doc_revs)
             superseded_revs = set(conflicted_doc_revs)
-            cur_conflicts = self._get_conflicts(doc_id)
+            cur_conflicts = self._get_conflicts(doc.doc_id)
             c = self._db_handle.cursor()
             if cur_doc.rev in superseded_revs:
-                self._put_and_update_indexes(doc_id, cur_doc.content,
-                                             new_rev, doc)
+                self._put_and_update_indexes(doc.doc_id, cur_doc.content,
+                                             new_rev, doc.content)
             else:
-                self._add_conflict(c, doc_id, new_rev, doc)
-            deleting = [(doc_id, c_rev) for c_rev in superseded_revs]
+                self._add_conflict(c, doc.doc_id, new_rev, doc.content)
+            deleting = [(doc.doc_id, c_rev) for c_rev in superseded_revs]
             c.executemany("DELETE FROM conflicts"
                           " WHERE doc_id=? AND doc_rev=?", deleting)
-            return new_rev, self._has_conflicts(doc_id)
+            doc.rev = new_rev
+            doc.has_conflicts = self._has_conflicts(doc.doc_id)
 
     def create_index(self, index_name, index_expression):
         with self._db_handle:

=== modified file 'u1db/tests/__init__.py'
--- u1db/tests/__init__.py	2011-11-22 11:09:00 +0000
+++ u1db/tests/__init__.py	2011-11-25 15:43:24 +0000
@@ -56,6 +56,20 @@
                            has_conflicts=has_conflicts)
         self.assertEqual(exp_doc, db.get_doc(doc_id))
 
+    def assertGetDocConflicts(self, db, doc_id, conflicts):
+        """Assert what conflicts are stored for a given doc_id.
+
+        :param conflicts: A list of (doc_Rev, content) pairs.
+            The first item must match the first item returned from the
+            database, however the rest can be returned in any order.
+        """
+        if conflicts:
+            conflicts = conflicts[:1] + sorted(conflicts[1:])
+        actual = db.get_doc_conflicts(doc_id)
+        if actual:
+            actual = actual[:1] + sorted(actual[1:])
+        self.assertEqual(conflicts, actual)
+
 
 def multiply_scenarios(a_scenarios, b_scenarios):
     """Create the cross-product of scenarios."""

=== modified file 'u1db/tests/test_backends.py'
--- u1db/tests/test_backends.py	2011-11-23 13:46:56 +0000
+++ u1db/tests/test_backends.py	2011-11-25 15:43:24 +0000
@@ -18,6 +18,7 @@
     Document,
     errors,
     tests,
+    vectorclock,
     )
 
 
@@ -108,6 +109,77 @@
             sorted(self.db.get_docs([doc1.doc_id, doc2.doc_id],
                                     check_for_conflicts=False)))
 
+    def test_resolve_doc(self):
+        doc = self.db.create_doc(simple_doc)
+        alt_doc = Document(doc.doc_id, 'alternate:1', nested_doc)
+        self.db.force_doc_sync_conflict(alt_doc)
+        self.assertEqual([('alternate:1', nested_doc),
+                          (doc.rev, simple_doc)],
+                         self.db.get_doc_conflicts(doc.doc_id))
+        orig_rev = doc.rev
+        self.db.resolve_doc(doc, [alt_doc.rev, doc.rev])
+        self.assertNotEqual(orig_rev, doc.rev)
+        self.assertFalse(doc.has_conflicts)
+        self.assertGetDoc(self.db, doc.doc_id, doc.rev, simple_doc, False)
+        self.assertEqual([], self.db.get_doc_conflicts(doc.doc_id))
+
+    def test_resolve_doc_picks_biggest_vcr(self):
+        doc1 = self.db.create_doc(simple_doc)
+        doc2 = Document(doc1.doc_id, 'alternate:1', nested_doc)
+        self.db.force_doc_sync_conflict(doc2)
+        self.assertGetDocConflicts(self.db, doc1.doc_id,
+                                   [(doc2.rev, nested_doc),
+                                    (doc1.rev, simple_doc)])
+        orig_doc1_rev = doc1.rev
+        self.db.resolve_doc(doc1, [doc2.rev, doc1.rev])
+        self.assertFalse(doc1.has_conflicts)
+        self.assertNotEqual(orig_doc1_rev, doc1.rev)
+        self.assertGetDoc(self.db, doc1.doc_id, doc1.rev, simple_doc, False)
+        self.assertGetDocConflicts(self.db, doc1.doc_id, [])
+        vcr_1 = vectorclock.VectorClockRev(orig_doc1_rev)
+        vcr_2 = vectorclock.VectorClockRev(doc2.rev)
+        vcr_new = vectorclock.VectorClockRev(doc1.rev)
+        self.assertTrue(vcr_new.is_newer(vcr_1))
+        self.assertTrue(vcr_new.is_newer(vcr_2))
+
+    def test_resolve_doc_partial_not_winning(self):
+        doc1 = self.db.create_doc(simple_doc)
+        doc2 = Document(doc1.doc_id, 'alternate:1', nested_doc)
+        self.db.force_doc_sync_conflict(doc2)
+        self.assertGetDocConflicts(self.db, doc1.doc_id,
+                                   [(doc2.rev, nested_doc),
+                                    (doc1.rev, simple_doc)])
+        content3 = '{"key": "valin3"}'
+        doc3 = Document(doc1.doc_id, 'third:1', content3)
+        self.db.force_doc_sync_conflict(doc3)
+        self.assertGetDocConflicts(self.db, doc1.doc_id,
+            [(doc3.rev, content3),
+             (doc1.rev, simple_doc),
+             (doc2.rev, nested_doc)])
+        self.db.resolve_doc(doc1, [doc2.rev, doc1.rev])
+        self.assertTrue(doc1.has_conflicts)
+        self.assertGetDoc(self.db, doc1.doc_id, doc3.rev, content3, True)
+        self.assertGetDocConflicts(self.db, doc1.doc_id,
+            [(doc3.rev, content3),
+             (doc1.rev, simple_doc)])
+
+    def test_resolve_doc_partial_winning(self):
+        doc1 = self.db.create_doc(simple_doc)
+        doc2 = Document(doc1.doc_id, 'alternate:1', nested_doc)
+        self.db.force_doc_sync_conflict(doc2)
+        content3 = '{"key": "valin3"}'
+        doc3 = Document(doc1.doc_id, 'third:1', content3)
+        self.db.force_doc_sync_conflict(doc3)
+        self.assertGetDocConflicts(self.db, doc1.doc_id,
+                                   [(doc3.rev, content3),
+                                    (doc1.rev, simple_doc),
+                                    (doc2.rev, nested_doc)])
+        self.db.resolve_doc(doc1, [doc3.rev, doc1.rev])
+        self.assertTrue(doc1.has_conflicts)
+        self.assertGetDocConflicts(self.db, doc1.doc_id,
+                                   [(doc1.rev, simple_doc),
+                                    (doc2.rev, nested_doc)])
+
     def test_get_docs_empty_list(self):
         self.assertEqual([], self.db.get_docs([]))
 

=== modified file 'u1db/tests/test_sync.py'
--- u1db/tests/test_sync.py	2011-11-22 11:09:00 +0000
+++ u1db/tests/test_sync.py	2011-11-25 15:43:24 +0000
@@ -422,87 +422,5 @@
                           (doc1.rev, simple_doc)],
                          self.db1.get_doc_conflicts(doc1.doc_id))
 
-    def test_resolve_doc(self):
-        doc1 = self.db1.create_doc(simple_doc)
-        doc_id = doc1.doc_id
-        content1 = '{"key": "altval"}'
-        doc2 = self.db2.create_doc(content1, doc_id=doc_id)
-        self.sync(self.db1, self.db2)
-        self.assertEqual([(doc2.rev, content1),
-                          (doc1.rev, simple_doc)],
-                         self.db1.get_doc_conflicts(doc_id))
-        new_rev, has_conflicts = self.db1.resolve_doc(doc_id, simple_doc,
-                                                     [doc2.rev, doc1.rev])
-        self.assertFalse(has_conflicts)
-        self.assertGetDoc(self.db1, doc_id, new_rev, simple_doc, False)
-        self.assertEqual([], self.db1.get_doc_conflicts(doc_id))
-
-    def test_resolve_doc_picks_biggest_vcr(self):
-        doc = self.db1.create_doc(simple_doc)
-        doc_id = doc.doc_id
-        doc1_rev = self.db1.put_doc(doc)
-        contents2 = '{"key": "altval"}'
-        doc2 = self.db2.create_doc(contents2, doc_id=doc_id)
-        doc2_rev = self.db2.put_doc(doc2)
-        self.sync(self.db1, self.db2)
-        self.assertEqual([(doc2_rev, contents2),
-                          (doc1_rev, simple_doc)],
-                         self.db1.get_doc_conflicts(doc_id))
-        new_rev, has_conflicts = self.db1.resolve_doc(doc_id, simple_doc,
-                                                     [doc2_rev, doc1_rev])
-        self.assertFalse(has_conflicts)
-        self.assertGetDoc(self.db1, doc_id, new_rev, simple_doc, False)
-        self.assertEqual([], self.db1.get_doc_conflicts(doc_id))
-        vcr_1 = vectorclock.VectorClockRev(doc1_rev)
-        vcr_2 = vectorclock.VectorClockRev(doc2_rev)
-        vcr_new = vectorclock.VectorClockRev(new_rev)
-        self.assertTrue(vcr_new.is_newer(vcr_1))
-        self.assertTrue(vcr_new.is_newer(vcr_2))
-
-    def test_resolve_doc_partial_not_winning(self):
-        doc1 = self.db1.create_doc(simple_doc)
-        doc_id = doc1.doc_id
-        content2 = '{"key": "valin2"}'
-        doc2 = self.db2.create_doc(content2, doc_id=doc_id)
-        self.sync(self.db1, self.db2)
-        self.assertEqual([(doc2.rev, content2),
-                          (doc1.rev, simple_doc)],
-                         self.db1.get_doc_conflicts(doc_id))
-        self.db3 = self.create_database('test3')
-        content3 = '{"key": "valin3"}'
-        doc3 = self.db3.create_doc(content3, doc_id=doc_id)
-        self.sync(self.db1, self.db3)
-        self.assertEqual([(doc3.rev, content3),
-                          (doc1.rev, simple_doc),
-                          (doc2.rev, content2)],
-                         self.db1.get_doc_conflicts(doc_id))
-        new_rev, has_conflicts = self.db1.resolve_doc(doc_id, simple_doc,
-                                                     [doc2.rev, doc1.rev])
-        self.assertTrue(has_conflicts)
-        self.assertGetDoc(self.db1, doc_id, doc3.rev, content3, True)
-        self.assertEqual([(doc3.rev, content3), (new_rev, simple_doc)],
-                         self.db1.get_doc_conflicts(doc_id))
-
-    def test_resolve_doc_partial_winning(self):
-        doc1 = self.db1.create_doc(simple_doc)
-        doc_id = doc1.doc_id
-        content2 = '{"key": "valin2"}'
-        doc2 = self.db2.create_doc(content2, doc_id=doc_id)
-        self.sync(self.db1, self.db2)
-        self.db3 = self.create_database('test3')
-        content3 = '{"key": "valin3"}'
-        doc3 = self.db3.create_doc(content3, doc_id=doc_id)
-        self.sync(self.db1, self.db3)
-        self.assertEqual([(doc3.rev, content3),
-                          (doc1.rev, simple_doc),
-                          (doc2.rev, content2)],
-                         self.db1.get_doc_conflicts(doc_id))
-        new_rev, has_conflicts = self.db1.resolve_doc(doc_id, simple_doc,
-                                                     [doc3.rev, doc1.rev])
-        self.assertTrue(has_conflicts)
-        self.assertEqual([(new_rev, simple_doc),
-                          (doc2.rev, content2)],
-                         self.db1.get_doc_conflicts(doc_id))
-
 
 load_tests = tests.load_with_scenarios