SERVER-19033 find command now validates the type of its first parameter

1 files changed, 139 insertions, 50 deletions

diff --git a/src/mongo/db/query/lite_parsed_query_test.cpp b/src/mongo/db/query/lite_parsed_query_test.cpp
index d31d0501b7e..5c2613eb41f 100644
--- a/src/mongo/db/query/lite_parsed_query_test.cpp
+++ b/src/mongo/db/query/lite_parsed_query_test.cpp
@@ -32,6 +32,7 @@
 #include <boost/optional/optional_io.hpp>
 
 #include "mongo/db/json.h"
+#include "mongo/db/namespace_string.h"
 #include "mongo/db/query/lite_parsed_query.h"
 #include "mongo/unittest/unittest.h"
 
@@ -333,8 +334,10 @@ namespace {
                                    "filter: {a: 3},"
                                    "sort: {a: 1},"
                                    "projection: {_id: 0, a: 1}}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandWithOptions) {
@@ -344,9 +347,10 @@ namespace {
                                    "projection: {_id: 0, a: 1},"
                                    "showRecordId: true,"
                                    "maxScan: 1000}}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
         unique_ptr<LiteParsedQuery> lpq(
-            assertGet(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain)));
+            assertGet(LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain)));
 
         // Make sure the values from the command BSON are reflected in the LPQ.
         ASSERT(lpq->showRecordId());
@@ -357,9 +361,10 @@ namespace {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "filter:  {a: 1},"
                                    "hint: 'foo_1'}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
         unique_ptr<LiteParsedQuery> lpq(
-            assertGet(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain)));
+            assertGet(LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain)));
 
         BSONObj hintObj = lpq->getHint();
         ASSERT_EQUALS(BSON("$hint" << "foo_1"), hintObj);
@@ -369,16 +374,18 @@ namespace {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "projection: {a: 1},"
                                    "sort: {a: 1}}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        ASSERT_OK(LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain).getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandValidSortProjMeta) {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "projection: {a: {$meta: 'textScore'}},"
                                    "sort: {a: {$meta: 'textScore'}}}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        ASSERT_OK(LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain).getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandAllFlagsTrue) {
@@ -389,9 +396,10 @@ namespace {
                                    "noCursorTimeout: true,"
                                    "awaitData: true,"
                                    "partial: true}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
         unique_ptr<LiteParsedQuery> lpq(
-            assertGet(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain)));
+            assertGet(LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain)));
 
         // Test that all the flags got set to true.
         ASSERT(lpq->isTailable());
@@ -407,9 +415,10 @@ namespace {
                                    "comment: 'the comment',"
                                    "min: {a: 1},"
                                    "max: {a: 2}}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
         unique_ptr<LiteParsedQuery> lpq(
-            assertGet(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain)));
+            assertGet(LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain)));
 
         ASSERT_EQUALS("the comment", lpq->getComment());
         BSONObj expectedMin = BSON("a" << 1);
@@ -428,9 +437,10 @@ namespace {
                                    "skip: 5,"
                                    "batchSize: 90,"
                                    "singleBatch: false}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
         unique_ptr<LiteParsedQuery> lpq(
-            assertGet(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain)));
+            assertGet(LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain)));
 
         // Check the values inside the LPQ.
         BSONObj expectedQuery = BSON("a" << 1);
@@ -454,24 +464,30 @@ namespace {
     TEST(LiteParsedQueryTest, ParseFromCommandQueryWrongType) {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "filter: 3}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandSortWrongType) {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "filter:  {a: 1},"
                                    "sort: 3}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandProjWrongType) {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "filter:  {a: 1},"
                                    "projection: 'foo'}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandSkipWrongType) {
@@ -479,8 +495,10 @@ namespace {
                                    "filter:  {a: 1},"
                                    "skip: '5',"
                                    "projection: {a: 1}}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandLimitWrongType) {
@@ -488,8 +506,10 @@ namespace {
                                    "filter:  {a: 1},"
                                    "limit: '5',"
                                    "projection: {a: 1}}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandSingleBatchWrongType) {
@@ -497,16 +517,20 @@ namespace {
                                    "filter:  {a: 1},"
                                    "singleBatch: 'false',"
                                    "projection: {a: 1}}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandCommentWrongType) {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "filter:  {a: 1},"
                                    "comment: 1}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandMaxScanWrongType) {
@@ -514,40 +538,50 @@ namespace {
                                    "filter:  {a: 1},"
                                    "maxScan: true,"
                                    "comment: 'foo'}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandMaxTimeMSWrongType) {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "filter:  {a: 1},"
                                    "maxTimeMS: true}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandMaxWrongType) {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "filter:  {a: 1},"
                                    "max: 3}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandMinWrongType) {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "filter:  {a: 1},"
                                    "min: 3}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandReturnKeyWrongType) {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "filter:  {a: 1},"
                                    "returnKey: 3}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
 
@@ -555,48 +589,60 @@ namespace {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "filter:  {a: 1},"
                                    "showRecordId: 3}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandSnapshotWrongType) {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "filter:  {a: 1},"
                                    "snapshot: 3}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandTailableWrongType) {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "filter:  {a: 1},"
                                    "tailable: 3}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandSlaveOkWrongType) {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "filter:  {a: 1},"
                                    "slaveOk: 3}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandOplogReplayWrongType) {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "filter:  {a: 1},"
                                    "oplogReplay: 3}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandNoCursorTimeoutWrongType) {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "filter:  {a: 1},"
                                    "noCursorTimeout: 3}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandAwaitDataWrongType) {
@@ -604,24 +650,30 @@ namespace {
                                    "filter:  {a: 1},"
                                    "tailable: true,"
                                    "awaitData: 3}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandExhaustWrongType) {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "filter:  {a: 1},"
                                    "exhaust: 3}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandPartialWrongType) {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "filter:  {a: 1},"
                                    "exhaust: 3}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     //
@@ -632,31 +684,38 @@ namespace {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "skip: -3,"
                                    "filter: {a: 3}}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandNegativeLimitError) {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "limit: -3,"
                                    "filter: {a: 3}}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandNegativeBatchSizeError) {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "batchSize: -10,"
                                    "filter: {a: 3}}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandBatchSizeZero) {
         BSONObj cmdObj = fromjson("{find: 'testns', batchSize: 0}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
         unique_ptr<LiteParsedQuery> lpq(
-            assertGet(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain)));
+            assertGet(LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain)));
 
         ASSERT(lpq->getBatchSize());
         ASSERT_EQ(0, lpq->getBatchSize());
@@ -666,9 +725,10 @@ namespace {
 
     TEST(LiteParsedQueryTest, ParseFromCommandDefaultBatchSize) {
         BSONObj cmdObj = fromjson("{find: 'testns'}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
         unique_ptr<LiteParsedQuery> lpq(
-            assertGet(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain)));
+            assertGet(LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain)));
 
         ASSERT(!lpq->getBatchSize());
         ASSERT(!lpq->getLimit());
@@ -682,24 +742,30 @@ namespace {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "min: {a: 3},"
                                    "max: {b: 4}}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandSnapshotPlusSortError) {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "sort: {a: 3},"
                                    "snapshot: true}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandSnapshotPlusHintError) {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "snapshot: true,"
                                    "hint: {a: 1}}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseCommandForbidNonMetaSortOnFieldWithMetaProject) {
@@ -708,13 +774,15 @@ namespace {
         cmdObj = fromjson("{find: 'testns',"
                            "projection: {a: {$meta: 'textScore'}},"
                            "sort: {a: 1}}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
 
         cmdObj = fromjson("{find: 'testns',"
                            "projection: {a: {$meta: 'textScore'}},"
                            "sort: {b: 1}}");
-        ASSERT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        ASSERT_OK(LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain).getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseCommandForbidMetaSortOnFieldWithoutMetaProject) {
@@ -723,28 +791,34 @@ namespace {
         cmdObj = fromjson("{find: 'testns',"
                            "projection: {a: 1},"
                            "sort: {a: {$meta: 'textScore'}}}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
 
         cmdObj = fromjson("{find: 'testns',"
                            "projection: {b: 1},"
                            "sort: {a: {$meta: 'textScore'}}}");
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseCommandForbidExhaust) {
         BSONObj cmdObj = fromjson("{find: 'testns', exhaust: true}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseCommandIsFromFindCommand) {
         BSONObj cmdObj = fromjson("{find: 'testns'}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
         unique_ptr<LiteParsedQuery> lpq(
-            assertGet(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain)));
+            assertGet(LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain)));
 
-        ASSERT(lpq->fromFindCommand());
+        ASSERT(lpq->isFromFindCommand());
     }
 
     TEST(LiteParsedQueryTest, ParseCommandNotFromFindCommand) {
@@ -761,24 +835,35 @@ namespace {
                                             BSONObj(),
                                             false,      // snapshot
                                             false)));   // explain
-        ASSERT(!lpq->fromFindCommand());
+        ASSERT(!lpq->isFromFindCommand());
     }
 
     TEST(LiteParsedQueryTest, ParseCommandAwaitDataButNotTailable) {
+        const NamespaceString nss("test.testns");
         BSONObj cmdObj = fromjson("{find: 'testns', awaitData: true}");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
+    }
+
+    TEST(LiteParsedQueryTest, ParseCommandFirstFieldNotString) {
+        BSONObj cmdObj = fromjson("{find: 1}");
+        const NamespaceString nss("test.testns");
+        bool isExplain = false;
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, DefaultQueryParametersCorrect) {
         BSONObj cmdObj = fromjson("{find: 'testns'}");
 
+        const NamespaceString nss("test.testns");
         std::unique_ptr<LiteParsedQuery> lpq(
-            assertGet(LiteParsedQuery::fromFindCommand("testns", cmdObj, false)));
+            assertGet(LiteParsedQuery::makeFromFindCommand(nss, cmdObj, false)));
 
         ASSERT_EQUALS(0, lpq->getSkip());
         ASSERT_EQUALS(true, lpq->wantMore());
-        ASSERT_EQUALS(true, lpq->fromFindCommand());
+        ASSERT_EQUALS(true, lpq->isFromFindCommand());
         ASSERT_EQUALS(false, lpq->isExplain());
         ASSERT_EQUALS(0, lpq->getMaxScan());
         ASSERT_EQUALS(0, lpq->getMaxTimeMS());
@@ -803,16 +888,20 @@ namespace {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "snapshot: true,"
                                    "foo: {a: 1}}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
     TEST(LiteParsedQueryTest, ParseFromCommandForbidExtraOption) {
         BSONObj cmdObj = fromjson("{find: 'testns',"
                                    "snapshot: true,"
                                    "foo: true}");
+        const NamespaceString nss("test.testns");
         bool isExplain = false;
-        ASSERT_NOT_OK(LiteParsedQuery::fromFindCommand("testns", cmdObj, isExplain).getStatus());
+        auto result = LiteParsedQuery::makeFromFindCommand(nss, cmdObj, isExplain);
+        ASSERT_NOT_OK(result.getStatus());
     }
 
 } // namespace mongo