Fix bugs in service/datastore

service/datastore/query_test.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package datastore
 
 import (
         "math"
         "testing"
 
@@ skipping 107 matching lines @@
         {"projecting an empty field",
                 nq().Project("hello", ""),
                 "",
                 "cannot filter/project on: \"\"", nil},
 
         {"projecting __key__",
                 nq().Project("hello", "__key__"),
                 "",
                 "cannot project on \"__key__\"", nil},
 
+        {"getting all the keys",
+                nq("").KeysOnly(true),
+                "SELECT __key__ ORDER BY `__key__`",
+                nil, nil},
+
         {"projecting a duplicate",
                 nq().Project("hello", "hello"),
                 "SELECT `hello` FROM `Foo` ORDER BY `hello`, `__key__`",
                 nil, nq().Project("hello")},
 
         {"projecting a duplicate (style 2)",
                 nq().Project("hello").Project("hello"),
                 "SELECT `hello` FROM `Foo` ORDER BY `hello`, `__key__`",
                 nil, nq().Project("hello")},
 
+        {"project distinct",
+                nq().Project("hello").Distinct(true),
+                "SELECT DISTINCT `hello` FROM `Foo` ORDER BY `hello`, `__key__`",
+                nil, nil},
+
         {"bad ancestors",
                 nq().Ancestor(mkKey("goop", 0)),
                 "",
                 ErrInvalidKey, nil},
 
         {"nil ancestors",
                 nq().Ancestor(nil),
                 "SELECT * FROM `Foo` ORDER BY `__key__`",
                 nil, nq()},
 
@@ skipping 40 matching lines @@
         {"kindless with non-__key__ orders",
                 nq("").Order("face"),
                 "",
                 "invalid order for kindless query", nil},
 
         {"kindless with descending-__key__ order",
                 nq("").Order("-__key__"),
                 "",
                 "invalid order for kindless query", nil},
 
+        {"kindless with equality filters",
+                nq("").Eq("hello", 1),
+                "",
+                "may not have any equality", nil},
+
+        {"kindless with ancestor filter",
+                nq("").Ancestor(mkKey("Parent", 1)),
+                "SELECT * WHERE __key__ HAS ANCESTOR KEY(DATASET(\"s~aid\"), NAMESPACE(\"ns\"), \"Parent\", 1) ORDER BY `__key__`",
+                nil, nil},
+
+        {"kindless with ancestor filter and __key__ ineq",
+                nq("").Ancestor(mkKey("Parent", 1)).Lt("__key__", mkKey("Parent", 1, "Sub", "hat")),
+                "SELECT * WHERE `__key__` < KEY(DATASET(\"s~aid\"), NAMESPACE(\"ns\"), \"Parent\", 1, \"Sub\", \"hat\") AND __key__ HAS ANCESTOR KEY(DATASET(\"s~aid\"), NAMESPACE(\"ns\"), \"Parent\", 1) ORDER BY `__key__`",
+                nil, nil},
+
         {"distinct non-projection",
                 nq().Distinct(true).Gt("marla", 1),
                 "SELECT * FROM `Foo` WHERE `marla` > 1 ORDER BY `marla`, `__key__`",
                 nil, nq().Gt("marla", 1)},
 
         {"chained errors return the first",
                 nq().Eq("__reserved__", 100).Eq("hello", "wurld").Order(""),
                 "",
                 "__reserved__", nil},
 
         {"multiple ancestors",
                 nq().Ancestor(mkKey("something", "correct")).Ancestor(mkKey("something", "else")),
                 ("SELECT * FROM `Foo` " +
                         "WHERE __key__ HAS ANCESTOR KEY(DATASET(\"s~aid\"), NAMESPACE(\"ns\"), \"something\", \"else\") " +
                         "ORDER BY `__key__`"),
                 nil, nq().Ancestor(mkKey("something", "else"))},
 
         {"filter with illegal type",
                 nq().Eq("something", complex(1, 2)),
                 "",
                 "bad type complex", nil},
 
         {"sort orders used for equality are ignored",
-                nq().Order("a", "b", "c").Eq("b", 2),
+                nq().Order("a", "b", "c").Eq("b", 2, 2),
                 "SELECT * FROM `Foo` WHERE `b` = 2 ORDER BY `a`, `c`, `__key__`",
                 nil, nq().Order("a", "c").Eq("b", 2)},
 
         {"sort orders used for equality are ignored (reversed)",
                 nq().Eq("b", 2).Order("a", "b", "c"),
                 "SELECT * FROM `Foo` WHERE `b` = 2 ORDER BY `a`, `c`, `__key__`",
                 nil,
                 nq().Order("a", "c").Eq("b", 2)},
 
         {"duplicate orders are ignored",
                 nq().Order("a").Order("a").Order("a"),
                 "SELECT * FROM `Foo` ORDER BY `a`, `__key__`",
                 nil,
                 nq().Order("a")},
 
         {"Filtering on a reserved property is forbidden",
                 nq().Gte("__special__", 10),
                 "",
                 "cannot filter/project on reserved property: \"__special__\"",
                 nil},
 
         {"in-bound key filters with ancestor OK",
-                nq().Ancestor(mkKey("Hello", 10)).Lt("__key__", mkKey("Hello", 10, "Something", "hi")),
+                nq().Ancestor(mkKey("Hello", 10)).Lte("__key__", mkKey("Hello", 10, "Something", "hi")),
                 ("SELECT * FROM `Foo` " +
-                        "WHERE `__key__` < KEY(DATASET(\"s~aid\"), NAMESPACE(\"ns\"), \"Hello\", 10, \"Something\", \"hi\") AND " +
+                        "WHERE `__key__` <= KEY(DATASET(\"s~aid\"), NAMESPACE(\"ns\"), \"Hello\", 10, \"Something\", \"hi\") AND " +
                         "__key__ HAS ANCESTOR KEY(DATASET(\"s~aid\"), NAMESPACE(\"ns\"), \"Hello\", 10) " +
                         "ORDER BY `__key__`"),
                 nil,
                 nil},
 
         {"projection elements get filled in",
                 nq().Project("Foo", "Bar").Order("-Bar"),
                 "SELECT `Bar`, `Foo` FROM `Foo` ORDER BY `Bar` DESC, `Foo`, `__key__`",
                 nil, nq().Project("Foo", "Bar").Order("-Bar").Order("Foo")},
 
         {"query without anything is fine",
                 nq(),
                 "SELECT * FROM `Foo` ORDER BY `__key__`",
                 nil,
                 nil},
+
+        {"ineq on __key__ with ancestor must be in range",

[dnj, 2015/09/29 19:06:23]

nit: is "in range" accurate here? The condition you're testing is an ancestor
difference. (Same for next test).

[iannucci, 2015/09/29 19:19:55]

updated

+                nq().Ancestor(mkKey("Hello", 10)).Lt("__key__", mkKey("Hello", 8)),
+                "",
+                "inequality filters on __key__ must be descendants of the __ancestor__", nil},
+
+        {"ineq on __key__ with ancestor must be in range (2)",
+                nq().Ancestor(mkKey("Hello", 10)).Gt("__key__", mkKey("Hello", 8)),
+                "",
+                "inequality filters on __key__ must be descendants of the __ancestor__", nil},
+
+        {"can build an empty query",
+                nq().Lt("hello", 10).Gt("hello", 50),
+                "",
+                ErrNullQuery, nil},
 }
 
 func TestQueries(t *testing.T) {
         t.Parallel()
 
         Convey("queries have tons of condition checking", t, func() {
                 for _, tc := range queryTests {
                         Convey(tc.name, func() {
                                 fq, err := tc.q.Finalize()
                                 if err == nil {
@@ skipping 10 matching lines @@
                                         So(err, ShouldBeNil)
 
                                         fq.original = nil
                                         fq2.original = nil
                                         So(fq, ShouldResemble, fq2)
                                 }
                         })
                 }
         })
 }