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

[John A Meinel]

Exposes "u1db-client delete db doc-id doc-rev"

[lp:~jameinel/u1db/client_delete_doc]

133. By John A Meinel on 2011-11-30

Add some focused tests on the error conditions.

134. By John A Meinel on 2011-11-30

Merge trunk to get u1db.open()

135. By John A Meinel on 2011-11-30

Change CmdDelete to use u1db_open.

[Samuele Pedroni (pedronis)]

+1

review: Approve

=== modified file 'u1db/commandline/client.py'
--- u1db/commandline/client.py	2011-11-30 13:09:38 +0000
+++ u1db/commandline/client.py	2011-11-30 14:25:32 +0000
@@ -56,6 +56,27 @@
 client_commands.register(CmdCreate)
 
 
+class CmdDelete(command.Command):
+    """Delete a document from the database"""
+
+    name = 'delete'
+
+    @classmethod
+    def _populate_subparser(cls, parser):
+        parser.add_argument('database', help='The database to update')
+        parser.add_argument('doc_id', help='The document id to retrieve')
+        parser.add_argument('doc_rev',
+            help='The revision of the document (which is being superseded.)')
+
+    def run(self, database, doc_id, doc_rev):
+        db = u1db_open(database, create=False)
+        doc = Document(doc_id, doc_rev, None)
+        db.delete_doc(doc)
+        self.stderr.write('rev: %s\n' % (doc.rev,))
+
+client_commands.register(CmdDelete)
+
+
 class CmdGet(command.Command):
     """Extract a document from the database"""
 

=== modified file 'u1db/tests/commandline/test_client.py'
--- u1db/tests/commandline/test_client.py	2011-11-23 12:39:27 +0000
+++ u1db/tests/commandline/test_client.py	2011-11-30 14:25:32 +0000
@@ -19,6 +19,7 @@
 
 from u1db import (
     __version__ as _u1db_version,
+    errors,
     tests,
     )
 from u1db.backends import (
@@ -30,6 +31,11 @@
 
 
 class TestArgs(tests.TestCase):
+    """These tests are meant to test just the argument parsing.
+
+    Each Command should have at least one test, possibly more if it allows
+    optional arguments, etc.
+    """
 
     def setUp(self):
         super(TestArgs, self).setUp()
@@ -58,6 +64,13 @@
         self.assertEqual('xyz', args.doc_id)
         self.assertEqual(None, args.infile)
 
+    def test_delete(self):
+        args = self.parse_args(['delete', 'test.db', 'doc-id', 'doc-rev'])
+        self.assertEqual(client.CmdDelete, args.subcommand)
+        self.assertEqual('test.db', args.database)
+        self.assertEqual('doc-id', args.doc_id)
+        self.assertEqual('doc-rev', args.doc_rev)
+
     def test_get(self):
         args = self.parse_args(['get', 'test.db', 'doc-id'])
         self.assertEqual(client.CmdGet, args.subcommand)
@@ -94,6 +107,12 @@
 
 
 class TestCaseWithDB(tests.TestCase):
+    """These next tests are meant to have one class per Command.
+
+    It is meant to test the inner workings of each command. The detailed
+    testing should happen in these classes. Stuff like how it handles errors,
+    etc. should be done here.
+    """
 
     def setUp(self):
         super(TestCaseWithDB, self).setUp()
@@ -124,6 +143,48 @@
                          cmd.stderr.getvalue())
 
 
+class TestCmdDelete(TestCaseWithDB):
+
+    def test_delete(self):
+        doc = self.db.create_doc(tests.simple_doc)
+        cmd = self.make_command(client.CmdDelete)
+        cmd.run(self.db_path, doc.doc_id, doc.rev)
+        doc2 = self.db.get_doc(doc.doc_id)
+        self.assertEqual(doc.doc_id, doc2.doc_id)
+        self.assertNotEqual(doc.rev, doc2.rev)
+        self.assertIs(None, doc2.content)
+        self.assertEqual('', cmd.stdout.getvalue())
+        self.assertEqual('rev: %s\n' % (doc2.rev,), cmd.stderr.getvalue())
+
+    def test_delete_fails_if_nonexistent(self):
+        doc = self.db.create_doc(tests.simple_doc)
+        db2_path = self.db_path + '.typo'
+        cmd = self.make_command(client.CmdDelete)
+        # TODO: We should really not be showing a traceback here. But we need
+        #       to teach the commandline infrastructure how to handle
+        #       exceptions.
+        #       However, we *do* want to test that the db doesn't get created
+        #       by accident.
+        self.assertRaises(errors.DatabaseDoesNotExist,
+            cmd.run, db2_path, doc.doc_id, doc.rev)
+        self.assertFalse(os.path.exists(db2_path))
+
+    def test_delete_no_such_doc(self):
+        cmd = self.make_command(client.CmdDelete)
+        # TODO: We should really not be showing a traceback here. But we need
+        #       to teach the commandline infrastructure how to handle
+        #       exceptions.
+        self.assertRaises(errors.DocumentDoesNotExist,
+            cmd.run, self.db_path, 'no-doc-id', 'no-rev')
+
+    def test_delete_bad_rev(self):
+        doc = self.db.create_doc(tests.simple_doc)
+        cmd = self.make_command(client.CmdDelete)
+        self.assertRaises(errors.RevisionConflict,
+            cmd.run, self.db_path, doc.doc_id, 'not-the-actual-doc-rev:1')
+        # TODO: Test that we get a pretty output.
+
+
 class TestCmdGet(TestCaseWithDB):
 
     def setUp(self):
@@ -215,6 +276,12 @@
 
 
 class TestCommandLine(TestCaseWithDB):
+    """These are meant to test that the infrastructure is fully connected.
+
+    Each command is likely to only have one test here. Something that ensures
+    'main()' knows about and can run the command correctly. Most logic-level
+    testing of the Command should go into its own test class above.
+    """
 
     def _get_u1db_client_path(self):
         from u1db import __path__ as u1db_path
@@ -236,7 +303,10 @@
         stderr = cStringIO.StringIO()
         self.patch(sys, 'stdout', stdout)
         self.patch(sys, 'stderr', stderr)
-        ret = client.main(args)
+        try:
+            ret = client.main(args)
+        except SystemExit, e:
+            self.fail("Intercepted SystemExit: %s" % (e,))
         if ret is None:
             ret = 0
         return ret, stdout.getvalue(), stderr.getvalue()
@@ -259,6 +329,15 @@
         self.assertEqual(tests.simple_doc, stdout)
         self.assertEqual('rev: %s\n' % (doc.rev,), stderr)
 
+    def test_delete(self):
+        doc = self.db.create_doc(tests.simple_doc, doc_id='test-id')
+        ret, stdout, stderr = self.run_main(
+            ['delete', self.db_path, 'test-id', doc.rev])
+        doc = self.db.get_doc('test-id')
+        self.assertEqual(0, ret)
+        self.assertEqual('', stdout)
+        self.assertEqual('rev: %s\n' % (doc.rev,), stderr)
+
     def test_init_db(self):
         path = self.working_dir + '/test2.db'
         ret, stdout, stderr = self.run_main(['init-db', path, 'uid'])