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

[John A Meinel]

Updates force_doc_sync_conflict to use a Document.

The only bit I'm not fully sure about is altering the passed in document to set the has_conflicts=True attribute.

However, it makes sense to me.

[Samuele Pedroni (pedronis)]

+1, yes I suppose it's good for consistency though the only caller in our current code doesn't care about the flag/doc afterward

review: Approve

=== modified file 'u1db/__init__.py'
--- u1db/__init__.py	2011-11-22 10:51:25 +0000
+++ u1db/__init__.py	2011-11-23 13:03:59 +0000
@@ -98,15 +98,15 @@
         """
         raise NotImplementedError(self.put_docs)
 
-    def force_doc_sync_conflict(self, doc_id, doc_rev, doc):
+    def force_doc_sync_conflict(self, doc):
         """Update documents even though they should conflict.
 
         This is used for synchronization, and should generally not be used by
         clients.
 
-        The content will be selected as the 'current' content for doc_id, even
-        though doc_rev may not supersede the currently stored revision.  The
-        currently stored document will be added to the list of conflict
+        The content will be selected as the 'current' content for doc.doc_id,
+        even though doc.rev may not supersede the currently stored revision.
+        The currently stored document will be added to the list of conflict
         alternatives for the given doc_id.
 
         The reason this forces the new content to be 'current' is so that we
@@ -116,9 +116,7 @@
         synchronize and think the data has propagated, but their local copy
         looks fine, and the remote copy is never updated again.)
 
-        :param doc_id: The indentifier for this document
-        :param doc_rev: The document revision for this document
-        :param doc: The JSON string for the document.
+        :param doc: A Document
         :return: None
         """
         raise NotImplementedError(self.force_doc_sync_conflict)

=== modified file 'u1db/backends/inmemory.py'
--- u1db/backends/inmemory.py	2011-11-21 13:50:39 +0000
+++ u1db/backends/inmemory.py	2011-11-23 13:03:59 +0000
@@ -166,10 +166,13 @@
         return (len(self._transaction_log),
                 set(self._transaction_log[old_generation:]))
 
-    def force_doc_sync_conflict(self, doc_id, doc_rev, doc):
-        my_doc_rev, my_doc = self._docs[doc_id]
-        self._conflicts.setdefault(doc_id, []).append((my_doc_rev, my_doc))
-        self._put_and_update_indexes(doc_id, my_doc, doc_rev, doc)
+    def force_doc_sync_conflict(self, doc):
+        my_doc_rev, my_content = self._docs[doc.doc_id]
+        self._conflicts.setdefault(doc.doc_id, []).append(
+            (my_doc_rev, my_content))
+        doc.has_conflicts = True
+        self._put_and_update_indexes(doc.doc_id, my_content, doc.rev,
+                                     doc.content)
 
 
 class InMemoryIndex(object):

=== modified file 'u1db/backends/sqlite_backend.py'
--- u1db/backends/sqlite_backend.py	2011-11-22 15:08:58 +0000
+++ u1db/backends/sqlite_backend.py	2011-11-23 13:03:59 +0000
@@ -339,16 +339,18 @@
             return super(SQLiteDatabase, self).put_doc_if_newer(
                 doc_id, doc_rev, doc)
 
-    def _add_conflict(self, c, doc_id, my_doc_rev, my_doc):
+    def _add_conflict(self, c, doc_id, my_doc_rev, my_content):
         c.execute("INSERT INTO conflicts VALUES (?, ?, ?)",
-                  (doc_id, my_doc_rev, my_doc))
+                  (doc_id, my_doc_rev, my_content))
 
-    def force_doc_sync_conflict(self, doc_id, doc_rev, doc):
+    def force_doc_sync_conflict(self, doc):
         with self._db_handle:
-            my_doc = self._get_doc(doc_id)
+            my_doc = self._get_doc(doc.doc_id)
             c = self._db_handle.cursor()
-            self._add_conflict(c, doc_id, my_doc.rev, my_doc.content)
-            self._put_and_update_indexes(doc_id, my_doc.content, doc_rev, doc)
+            self._add_conflict(c, doc.doc_id, my_doc.rev, my_doc.content)
+            doc.has_conflicts = True
+            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):
         with self._db_handle:

=== modified file 'u1db/sync.py'
--- u1db/sync.py	2011-11-21 14:18:51 +0000
+++ u1db/sync.py	2011-11-23 13:03:59 +0000
@@ -60,8 +60,7 @@
             assert state == 'conflicted'
             # take doc as the official value, stores the current
             # alongside as conflict
-            self.source.force_doc_sync_conflict(doc.doc_id, doc.rev,
-                                                doc.content)
+            self.source.force_doc_sync_conflict(doc)
             self.num_inserted += 1
 
     def _record_sync_info_with_the_target(self, start_generation):

=== modified file 'u1db/tests/test_backends.py'
--- u1db/tests/test_backends.py	2011-11-21 14:32:17 +0000
+++ u1db/tests/test_backends.py	2011-11-23 13:03:59 +0000
@@ -93,15 +93,15 @@
 
     def test_get_docs_conflicted(self):
         doc1 = self.db.create_doc(simple_doc)
-        self.db.force_doc_sync_conflict(doc1.doc_id, 'alternate:1', nested_doc)
-        self.assertEqual(
-            [Document(doc1.doc_id, 'alternate:1', nested_doc, True)],
-            self.db.get_docs([doc1.doc_id]))
+        doc2 = Document(doc1.doc_id, 'alternate:1', nested_doc)
+        self.db.force_doc_sync_conflict(doc2)
+        self.assertEqual([doc2], self.db.get_docs([doc1.doc_id]))
 
     def test_get_docs_conflicts_ignored(self):
         doc1 = self.db.create_doc(simple_doc)
         doc2 = self.db.create_doc(nested_doc)
-        self.db.force_doc_sync_conflict(doc1.doc_id, 'alternate:1', nested_doc)
+        alt_doc = Document(doc1.doc_id, 'alternate:1', nested_doc)
+        self.db.force_doc_sync_conflict(alt_doc)
         self.assertEqual(
             sorted([Document(doc1.doc_id, 'alternate:1', nested_doc),
                     Document(doc2.doc_id, doc2.rev, nested_doc)]),
@@ -148,7 +148,9 @@
 
     def test_force_doc_with_conflict(self):
         doc1 = self.db.create_doc(simple_doc)
-        self.db.force_doc_sync_conflict(doc1.doc_id, 'alternate:1', nested_doc)
+        doc2 = Document(doc1.doc_id, 'alternate:1', nested_doc)
+        self.db.force_doc_sync_conflict(doc2)
+        self.assertTrue(doc2.has_conflicts)
         self.assertGetDoc(self.db, doc1.doc_id, 'alternate:1', nested_doc, True)
         self.assertEqual([('alternate:1', nested_doc),
                           (doc1.rev, simple_doc)],