Merge lp:~chipaca/u1db/u1db-client_first_pass_of_get-from-index into lp:u1db

[John Lenton]

get-from-index for u1db-client.

A get-from-index for u1db-client. Missing is splitting the backend's InvalidValueForIndex to differentiate the "bad glob" error and provide better help.

I was going to shelve this and do that, but then realized it wasn't really necessary.

[Eric Casteleijn (thisfred)]

Looks great

review: Approve

=== modified file 'u1db/commandline/client.py'
--- u1db/commandline/client.py	2012-05-21 17:32:38 +0000
+++ u1db/commandline/client.py	2012-05-23 08:32:18 +0000
@@ -18,6 +18,7 @@
 
 import argparse
 import os
+import simplejson
 import sys
 
 from u1db import (
@@ -322,9 +323,70 @@
             return
         return 1
 
-
 client_commands.register(CmdGetIndexKeys)
 
 
+class CmdGetFromIndex(OneDbCmd):
+    """Find documents by searching an index"""
+
+    name = "get-from-index"
+    argv = None
+
+    @classmethod
+    def _populate_subparser(cls, parser):
+        parser.add_argument('database', help='The local database to query',
+                            metavar='database-path')
+        parser.add_argument('index', help='the name of the index')
+        parser.add_argument('values', metavar="value",
+                            help='the value to look up (one per index column)',
+                            nargs="+")
+
+    def run(self, database, index, values):
+        try:
+            db = self._open(database, create=False)
+            docs = db.get_from_index(index, [values])
+        except errors.DatabaseDoesNotExist:
+            self.stderr.write("Database does not exist.\n")
+        except errors.IndexDoesNotExist:
+            self.stderr.write("Index does not exist.\n")
+        except errors.InvalidValueForIndex:
+            index_def = db._get_index_definition(index)
+            msg = ["Invalid query;"]
+            len_diff = len(index_def) - len(values)
+            if len_diff:
+                msg.append("index %r requires %d query expression%s"
+                           % (index, len(index_def),
+                              "s" if len(index_def) > 1 else ""))
+                if len(values):
+                    msg[-1] += ", not %d" % len(values)
+                if len_diff > 0:
+                    msg[-1] += ".\nPerhaps you meant:"
+                    argv = self.argv if self.argv is not None else sys.argv
+                    msg.extend(argv[:2])
+                    msg.append(repr(database))
+                    msg.extend(map(repr, values))
+                    msg.extend(["'*'" for i in range(len_diff)])
+            else:
+                # can't happen (HAH)
+                msg.append("not sure how to help you (read the docs?)")
+            self.stderr.write(" ".join(msg))
+            self.stderr.write(".\n")
+        else:
+            self.stdout.write("[")
+            for i, doc in enumerate(docs):
+                if i:
+                    self.stdout.write(",")
+                self.stdout.write(simplejson.dumps(dict(
+                            id=doc.doc_id,
+                            rev=doc.rev,
+                            content=simplejson.loads(doc.content)),
+                                                   indent=4))
+            self.stdout.write("]\n")
+            return
+        return 1
+
+client_commands.register(CmdGetFromIndex)
+
+
 def main(args):
     return client_commands.run_argv(args, sys.stdin, sys.stdout, sys.stderr)

=== modified file 'u1db/tests/commandline/test_client.py'
--- u1db/tests/commandline/test_client.py	2012-05-21 17:32:38 +0000
+++ u1db/tests/commandline/test_client.py	2012-05-23 08:32:18 +0000
@@ -17,6 +17,7 @@
 import cStringIO
 import os
 import sys
+import simplejson
 import subprocess
 
 from u1db import (
@@ -145,6 +146,13 @@
         self.assertEqual('db', args.database)
         self.assertEqual('index', args.index)
 
+    def test_get_from_index(self):
+        args = self.parse_args(['get-from-index', 'db', 'index', 'foo'])
+        self.assertEqual(client.CmdGetFromIndex, args.subcommand)
+        self.assertEqual('db', args.database)
+        self.assertEqual('index', args.index)
+        self.assertEqual(['foo'], args.values)
+
 
 class TestCaseWithDB(tests.TestCase):
     """These next tests are meant to have one class per Command.
@@ -472,6 +480,89 @@
         self.assertEqual(cmd.stderr.getvalue(), 'Index does not exist.\n')
 
 
+class TestCmdGetFromIndex(TestCaseWithDB):
+
+    def test_get_from_index(self):
+        self.db.create_index("index", ["key"])
+        doc1 = self.db.create_doc(tests.simple_doc)
+        doc2 = self.db.create_doc(tests.nested_doc)
+        cmd = self.make_command(client.CmdGetFromIndex)
+        retval = cmd.run(self.db_path, "index", ["value"])
+        self.assertEqual(retval, None)
+        self.assertEqual(sorted(simplejson.loads(cmd.stdout.getvalue())),
+                         sorted([dict(id=doc1.doc_id,
+                                      rev=doc1.rev,
+                                      content=simplejson.loads(doc1.content)),
+                                 dict(id=doc2.doc_id,
+                                      rev=doc2.rev,
+                                      content=simplejson.loads(doc2.content)),
+                                 ]))
+        self.assertEqual(cmd.stderr.getvalue(), '')
+
+    def test_get_from_index_empty(self):
+        self.db.create_index("index", ["key"])
+        cmd = self.make_command(client.CmdGetFromIndex)
+        retval = cmd.run(self.db_path, "index", ["value"])
+        self.assertEqual(retval, None)
+        self.assertEqual(cmd.stdout.getvalue(), '[]\n')
+        self.assertEqual(cmd.stderr.getvalue(), '')
+
+    def test_get_from_index_no_db(self):
+        cmd = self.make_command(client.CmdGetFromIndex)
+        retval = cmd.run(self.db_path + "__DOES_NOT_EXIST", "foo", [])
+        self.assertEqual(retval, 1)
+        self.assertEqual(cmd.stdout.getvalue(), '')
+        self.assertEqual(cmd.stderr.getvalue(), 'Database does not exist.\n')
+
+    def test_get_from_index_no_index(self):
+        cmd = self.make_command(client.CmdGetFromIndex)
+        retval = cmd.run(self.db_path, "foo", [])
+        self.assertEqual(retval, 1)
+        self.assertEqual(cmd.stdout.getvalue(), '')
+        self.assertEqual(cmd.stderr.getvalue(), 'Index does not exist.\n')
+
+    def test_get_from_index_two_expr_instead_of_one(self):
+        self.db.create_index("index", ["key1"])
+        cmd = self.make_command(client.CmdGetFromIndex)
+        retval = cmd.run(self.db_path, "index", ["value1", "value2"])
+        self.assertEqual(retval, 1)
+        self.assertEqual(cmd.stdout.getvalue(), '')
+        self.assertEqual(cmd.stderr.getvalue(), "Invalid query; index"
+                         " 'index' requires 1 query expression, not 2.\n")
+
+    def test_get_from_index_three_expr_instead_of_two(self):
+        self.db.create_index("index", ["key1", "key2"])
+        cmd = self.make_command(client.CmdGetFromIndex)
+        retval = cmd.run(self.db_path, "index", ["value1", "value2", "value3"])
+        self.assertEqual(retval, 1)
+        self.assertEqual(cmd.stdout.getvalue(), '')
+        self.assertEqual(cmd.stderr.getvalue(), "Invalid query; index"
+                         " 'index' requires 2 query expressions, not 3.\n")
+
+    def test_get_from_index_one_expr_instead_of_two(self):
+        self.db.create_index("index", ["key1", "key2"])
+        cmd = self.make_command(client.CmdGetFromIndex)
+        cmd.argv = ["XX", "YY"]
+        retval = cmd.run(self.db_path, "index", ["value1"])
+        self.assertEqual(retval, 1)
+        self.assertEqual(cmd.stdout.getvalue(), '')
+        self.assertEqual(cmd.stderr.getvalue(), "Invalid query; index"
+                         " 'index' requires 2 query expressions, not 1.\n"
+                         "Perhaps you meant: XX YY %r 'value1' '*'.\n"
+                         % self.db_path)
+
+    def test_get_from_index_cant_bad_glob(self):
+        self.db.create_index("index", ["key1", "key2"])
+        cmd = self.make_command(client.CmdGetFromIndex)
+        retval = cmd.run(self.db_path, "index", ["*", "a"])
+        self.assertEqual(retval, 1)
+        self.assertEqual(cmd.stdout.getvalue(), '')
+        # temp error until we split exceptions in the backend
+        # (in a later commit)
+        self.assertEqual(cmd.stderr.getvalue(), "Invalid query;"
+                         " not sure how to help you (read the docs?).\n")
+
+
 class RunMainHelper(object):
 
     def run_main(self, args, stdin=None):