From 4580fe1b3e01d8651fcec46522e506d82b0824c0 Mon Sep 17 00:00:00 2001
From: Mark Benvenuto <mark.benvenuto@mongodb.com>
Date: Tue, 16 Dec 2014 13:32:46 -0500
Subject: SERVER-16061: remove "text" command

---
 jstests/core/fts1.js           | 20 +++++++++++
 jstests/core/fts2.js           |  3 --
 jstests/core/fts3.js           |  2 --
 jstests/core/fts4.js           |  2 --
 jstests/core/fts5.js           |  3 --
 jstests/core/fts_blog.js       | 16 ++++-----
 jstests/core/fts_blogwild.js   | 26 +++++++-------
 jstests/core/fts_mix.js        | 82 +++++++++++++++++++++---------------------
 jstests/core/fts_partition1.js | 13 ++++---
 jstests/core/fts_phrase.js     | 18 +++++-----
 jstests/core/fts_proj.js       | 12 +++----
 jstests/core/fts_spanish.js    |  6 ++--
 12 files changed, 105 insertions(+), 98 deletions(-)
 create mode 100644 jstests/core/fts1.js

(limited to 'jstests/core')

diff --git a/jstests/core/fts1.js b/jstests/core/fts1.js
new file mode 100644
index 00000000000..367cdf96262
--- /dev/null
+++ b/jstests/core/fts1.js
@@ -0,0 +1,20 @@
+load( "jstests/libs/fts.js" );
+
+t = db.text1;
+t.drop();
+
+t.ensureIndex( { x : "text" } );
+
+assert.eq( [] , queryIDS( t , "az" ) , "A0" );
+
+t.save( { _id : 1 , x : "az b c" } );
+t.save( { _id : 2 , x : "az b" } );
+t.save( { _id : 3 , x : "b c" } );
+t.save( { _id : 4 , x : "b c d" } );
+
+assert.eq( [1,2,3,4] , queryIDS( t , "c az" ) , "A1" );
+assert.eq( [4] , queryIDS( t , "d" ) , "A2" );
+
+idx = t.getIndexes()[1];
+assert( idx.v >= 1, tojson( idx ) )
+assert( idx.textIndexVersion >= 1, tojson( idx ) )
diff --git a/jstests/core/fts2.js b/jstests/core/fts2.js
index bfd11728779..11b74a76b0b 100644
--- a/jstests/core/fts2.js
+++ b/jstests/core/fts2.js
@@ -18,7 +18,4 @@ assert.eq( [2] , queryIDS( t , "y" ) , "A4" );
 assert.eq( [1] , queryIDS( t , "az" , { z : 1 } ) , "B1" );
 assert.eq( [1] , queryIDS( t , "d" , { z : 1 } ) , "B2" );
 
-printjson(lastCommadResult);
-assert.eq( 4 , lastCommadResult.stats.nscannedObjects , "B3" );
-assert.eq( 2 , lastCommadResult.stats.nscanned , "B4" );
 
diff --git a/jstests/core/fts3.js b/jstests/core/fts3.js
index f5f72c4df0a..8c550259d10 100644
--- a/jstests/core/fts3.js
+++ b/jstests/core/fts3.js
@@ -18,5 +18,3 @@ assert.eq( [2] , queryIDS( t , "y" ) , "A4" );
 assert.eq( [1] , queryIDS( t , "az" , { z : 1 } ) , "B1" );
 assert.eq( [1] , queryIDS( t , "d" , { z : 1 } ) , "B2" );
 
-assert.eq( 0 , lastCommadResult.stats.nscannedObjects , "B3" );
-assert.eq( 2 , lastCommadResult.stats.nscanned , "B4" );
diff --git a/jstests/core/fts4.js b/jstests/core/fts4.js
index 8598457b033..fe35bdafe44 100644
--- a/jstests/core/fts4.js
+++ b/jstests/core/fts4.js
@@ -18,5 +18,3 @@ assert.eq( [2] , queryIDS( t , "y" ) , "A4" );
 assert.eq( [1] , queryIDS( t , "az" , { z : 1 } ) , "B1" );
 assert.eq( [1] , queryIDS( t , "d" , { z : 1 } ) , "B2" );
 
-assert.eq( 0 , lastCommadResult.stats.nscannedObjects , "B3" );
-assert.eq( 2 , lastCommadResult.stats.nscanned , "B4" );
diff --git a/jstests/core/fts5.js b/jstests/core/fts5.js
index a3097b47a4a..a95917f5d26 100644
--- a/jstests/core/fts5.js
+++ b/jstests/core/fts5.js
@@ -17,6 +17,3 @@ assert.eq( [2] , queryIDS( t , "y" ) , "A4" );
 
 assert.eq( [1] , queryIDS( t , "az" , { z: 1 } ) , "B1" );
 assert.eq( [1] , queryIDS( t , "d" , { z: 1 } ) , "B2" );
-
-assert.eq( 0 , lastCommadResult.stats.nscannedObjects , "B3" );
-assert.eq( 2 , lastCommadResult.stats.nscanned , "B4" );
diff --git a/jstests/core/fts_blog.js b/jstests/core/fts_blog.js
index 38cbb826eff..78b9ef34ecc 100644
--- a/jstests/core/fts_blog.js
+++ b/jstests/core/fts_blog.js
@@ -9,14 +9,14 @@ t.save( { _id : 3 , title : "knives are Fun" , text : "this is a new blog i am w
 // specify weights if you want a field to be more meaningull
 t.ensureIndex( { "title" : "text" , text : "text" } , { weights : { title : 10 } } );
 
-res = t.runCommand( "text" , { search : "blog" } )
-assert.eq( 3, res.results.length );
-assert.eq( 1, res.results[0].obj._id );
-
-res = t.runCommand( "text" , { search : "write" } )
-assert.eq( 3, res.results.length );
-assert.eq( res.results[0].score, res.results[1].score );
-assert.eq( res.results[0].score, res.results[2].score );
+res = t.find( { "$text" : { "$search" : "blog" } } ,  { score: { "$meta" : "textScore" } }  ).sort( { score: { "$meta" : "textScore" } });
+assert.eq( 3, res.length());
+assert.eq( 1, res[0]._id );
+
+res = t.find( { "$text" : { "$search" : "write" } }, { score: { "$meta" : "textScore" } } );
+assert.eq( 3, res.length() );
+assert.eq( res[0].score, res[1].score );
+assert.eq( res[0].score, res[2].score );
 
 
 
diff --git a/jstests/core/fts_blogwild.js b/jstests/core/fts_blogwild.js
index ecad0ce0b19..e220bd89032 100644
--- a/jstests/core/fts_blogwild.js
+++ b/jstests/core/fts_blogwild.js
@@ -9,11 +9,11 @@ t.save( { _id: 3 , title: "knives are Fun for writing eliot" , text: "this is a
 // specify weights if you want a field to be more meaningull
 t.ensureIndex( { dummy: "text" } , { weights: "$**" } );
 
-res = t.runCommand( "text" , { search: "blog" } );
-assert.eq( 3 , res.stats.n , "A1" );
+res = t.find( { "$text" : { "$search": "blog" } } );
+assert.eq( 3 , res.length() , "A1" );
 
-res = t.runCommand( "text" , { search: "write" } );
-assert.eq( 3 , res.stats.n , "B1" );
+res = t.find( { "$text" : { "$search": "write" } } );
+assert.eq( 3 , res.length() , "B1" );
 
 // mixing
 t.dropIndex( "dummy_text" );
@@ -21,17 +21,17 @@ assert.eq( 1 , t.getIndexKeys().length , "C1" );
 t.ensureIndex( { dummy: "text" } , { weights: { "$**": 1 , title: 2 } } );
 
 
-res = t.runCommand( "text" , { search: "write" } );
-assert.eq( 3 , res.stats.n , "C2" );
-assert.eq( 3 , res.results[0].obj._id , "C3" );
+res = t.find( { "$text" : { "$search": "write" } },  { score: { "$meta" : "textScore" } }  ).sort( { score: { "$meta" : "textScore" } });
+assert.eq( 3 , res.length() , "C2" );
+assert.eq( 3 , res[0]._id , "C3" );
 
-res = t.runCommand( "text" , { search: "blog" } );
-assert.eq( 3 , res.stats.n , "D1" );
-assert.eq( 1 , res.results[0].obj._id , "D2" );
+res = t.find( { "$text" : { "$search": "blog" } },  { score: { "$meta" : "textScore" } }  ).sort( { score: { "$meta" : "textScore" } });
+assert.eq( 3 , res.length() , "D1" );
+assert.eq( 1 , res[0]._id , "D2" );
 
-res = t.runCommand( "text" , { search: "eliot" } );
-assert.eq( 2 , res.stats.n , "E1" );
-assert.eq( 3 , res.results[0].obj._id , "E2" );
+res = t.find( { "$text" : { "$search": "eliot" } },  { score: { "$meta" : "textScore" } }  ).sort( { score: { "$meta" : "textScore" } });
+assert.eq( 2 , res.length() , "E1" );
+assert.eq( 3 , res[0]._id , "E2" );
 
 
 
diff --git a/jstests/core/fts_mix.js b/jstests/core/fts_mix.js
index 56da123cdc3..be42897ebe7 100644
--- a/jstests/core/fts_mix.js
+++ b/jstests/core/fts_mix.js
@@ -26,9 +26,9 @@ tc.save( { _id: 10, title: "Mallacoota, Victoria", text: "Mallacoota is a small
 tc.ensureIndex( { "title": "text" } );
 
 // test the single result case..
-res = tc.runCommand( "text", { search: "Victoria" } );
-assert.eq( 1, res.results.length );
-assert.eq( 10, res.results[0].obj._id );
+res = tc.find( { "$text": { "$search": "Victoria" } } );
+assert.eq( 1, res.length() );
+assert.eq( 10, res[0]._id );
 
 tc.dropIndexes();
 
@@ -50,68 +50,66 @@ assert.eq( [7,5], queryIDS( tc, "Olympic Games gold medal" ) );
 
 tc.dropIndexes();
 
-// -------------------------------------------- SEARCHING ------------------------------------------
+// -------------------------------------------- "search"ING ------------------------------------------
 
-// go back to "$**": 1, "title": 10.. and test more specific search functionality!
+// go back to "$**": 1, "title": 10.. and test more specific "search" functionality!
 tc.ensureIndex( { "$**": "text" }, { weights: { "title": 10 } } );
 
 // -------------------------------------------- STEMMING -------------------------------------------
 
 // tests stemming for basic plural case
-res = tc.runCommand( "text", { search: "member" } );
-res2 = tc.runCommand( "text", { search: "members" } );
+res = tc.find( { "$text": { "$search": "member" } } );
+res2 = tc.find( { "$text": { "$search": "members" } } );
 assert.eq( getIDS( res ), getIDS( res2 ) );
 
-// search for something with potential 's bug.
-res = tc.runCommand( "text", { search: "magazine's" } );
-res2 = tc.runCommand( "text", { search: "magazine" } );
+// "search" for something with potential 's bug.
+res = tc.find( { "$text": { "$search": "magazine's" } } );
+res2 = tc.find( { "$text": { "$search": "magazine" } } );
 assert.eq( getIDS( res ), getIDS( res2 ) );
 
 // -------------------------------------------- LANGUAGE -------------------------------------------
 
-res = tc.runCommand( "text", { search: "member", language: "spanglish" } );
-assert.commandFailed( res );
-res = tc.runCommand( "text", { search: "member", language: "english" } );
-assert.commandWorked( res );
+assert.throws(tc.find( { "$text": { "$search": "member", $language: "spanglish" } } ));
+assert.doesNotThrow(function() {tc.find( { "$text": { "$search": "member", $language: "english" } })} );
 
 // -------------------------------------------- LIMIT RESULTS --------------------------------------
 
 // ensure limit limits results
-assert.eq( [2], queryIDS( tc, "rural river dam", null , { limit : 1 } ) );
+assert.eq( [2], queryIDS( tc, "rural river dam", null, null, 1) );
 
 // ensure top results are the same regardless of limit
 // make sure that this uses a case where it wouldn't be otherwise..
-res = tc.runCommand( "text", { search: "united kingdom british princes", limit: 1 } );
-res2 = tc.runCommand( "text", { search: "united kingdom british princes" } );
-assert.eq( 1, res.results.length );
-assert.eq( 4, res2.results.length );
-assert.eq( res.results[0].obj._id, res2.results[0].obj._id );
+res = tc.find( { "$text": { "$search": "united kingdom british princes" }}).limit(1);
+res2 = tc.find( { "$text": { "$search": "united kingdom british princes" } } );
+assert.eq( 1, res.length() );
+assert.eq( 4, res2.length() );
+assert.eq( res[0]._id, res2[0]._id );
 
 // -------------------------------------------- PROJECTION -----------------------------------------
 
 // test projection.. show just title and id
-res = tc.runCommand( "text", { search: "Morten Jensen", project: { title: 1 } } );
-assert.eq( 1, res.results.length );
-assert.eq( 5, res.results[0].obj._id );
-assert.eq( null, res.results[0].obj.text );
-assert.neq( null, res.results[0].obj.title );
-assert.neq( null, res.results[0].obj._id );
+res = tc.find( { "$text": { "$search": "Morten Jensen" }}, { title: 1 } );
+assert.eq( 1, res.length() );
+assert.eq( 5, res[0]._id );
+assert.eq( null, res[0].text );
+assert.neq( null, res[0].title );
+assert.neq( null, res[0]._id );
 
 // test negative projection, ie. show everything but text
-res = tc.runCommand( "text", { search: "handball", project: { text: 0 } } );
-assert.eq( 1, res.results.length );
-assert.eq( 4, res.results[0].obj._id );
-assert.eq( null, res.results[0].obj.text );
-assert.neq( null, res.results[0].obj.title );
-assert.neq( null, res.results[0].obj._id );
+res = tc.find( { "$text": { "$search": "handball" }}, { text: 0 } );
+assert.eq( 1, res.length() );
+assert.eq( 4, res[0]._id );
+assert.eq( null, res[0].text );
+assert.neq( null, res[0].title );
+assert.neq( null, res[0]._id );
 
 // test projection only title, no id
-res = tc.runCommand( "text", { search: "Mahim Bora", project: { _id: 0, title: 1 } } );
-assert.eq( 1, res.results.length );
-assert.eq( "Mahim Bora", res.results[0].obj.title );
-assert.eq( null, res.results[0].obj.text );
-assert.neq( null, res.results[0].obj.title );
-assert.eq( null, res.results[0].obj._id );
+res = tc.find( { "$text": { "$search": "Mahim Bora" }}, { _id: 0, title: 1 } );
+assert.eq( 1, res.length() );
+assert.eq( "Mahim Bora", res[0].title );
+assert.eq( null, res[0].text );
+assert.neq( null, res[0].title );
+assert.eq( null, res[0]._id );
 
 // -------------------------------------------- NEGATION -------------------------------------------
 
@@ -136,12 +134,12 @@ assert.eq( [3], queryIDS( tc, "\"industry\" -Melbourne -Physics" ) );
 // -------------------------------------------- EDGE CASES -----------------------------------------
 
 // test empty string
-res = tc.runCommand( "text", { search: "" } );
-assert.eq( 0, res.ok )
+res = tc.find( { "$text": { "$search": "" } } );
+assert.eq( 0, res.length() );
 
 // test string with a space in it
-res = tc.runCommand( "text", { search: " " } );
-assert.eq( 0, res.results.length );
+res = tc.find( { "$text": { "$search": " " } } );
+assert.eq( 0, res.length() );
 
 // -------------------------------------------- FILTERING ------------------------------------------
 
diff --git a/jstests/core/fts_partition1.js b/jstests/core/fts_partition1.js
index f1b4c437c3c..c5c231db96d 100644
--- a/jstests/core/fts_partition1.js
+++ b/jstests/core/fts_partition1.js
@@ -10,14 +10,13 @@ t.insert( { _id : 4 , x : 2 , y : "bar" } );
 
 t.ensureIndex( { x : 1, y : "text" } );
 
-res = t.runCommand( "text", { search : "foo" } );
-assert.eq( 0, res.ok, tojson(res) );
+assert.throws(t.find( { "$text": { "$search" : "foo" } } ));
 
 assert.eq( [ 1 ], queryIDS( t, "foo" , { x : 1 } ) );
 
-res = t.runCommand( "text", { search : "foo" , filter : { x : 1 } } );
-assert( res.results[0].score > 0, tojson( res ) )
+res = t.find( { "$text": { "$search" : "foo" }, x : 1 }, { score: { "$meta" : "textScore" } } );
+assert( res[0].score > 0, tojson(res.toArray()));
 
-// repeat search with "language" specified, SERVER-8999
-res = t.runCommand( "text", { search : "foo" , filter : { x : 1 } , language : "english" } );
-assert( res.results[0].score > 0, tojson( res ) )
+// repeat "search" with "language" specified, SERVER-8999
+res = t.find( { "$text": { "$search" : "foo" , "$language" : "english" }, x : 1 }, { score: { "$meta" : "textScore" } } );
+assert( res[0].score > 0, tojson(res.toArray()));
diff --git a/jstests/core/fts_phrase.js b/jstests/core/fts_phrase.js
index 0b58bef817e..75280c81304 100644
--- a/jstests/core/fts_phrase.js
+++ b/jstests/core/fts_phrase.js
@@ -8,15 +8,15 @@ t.save( { _id : 3 , title : "knives are Fun" , text : "this is a new blog i am w
 
 t.ensureIndex( { "title" : "text" , text : "text" } , { weights : { title : 10 } } );
 
-res = t.runCommand( "text" , { search : "blog write" } );
-assert.eq( 3, res.results.length );
-assert.eq( 1, res.results[0].obj._id );
-assert( res.results[0].score > (res.results[1].score*2), tojson(res) );
-
-res = t.runCommand( "text" , { search : "write blog" } );
-assert.eq( 3, res.results.length );
-assert.eq( 1, res.results[0].obj._id );
-assert( res.results[0].score > (res.results[1].score*2), tojson(res) );
+res = t.find( { "$text" : { "$search" : "blog write" } }, { score: { "$meta" : "textScore" } }  ).sort( { score: { "$meta" : "textScore" } });
+assert.eq( 3, res.length() );
+assert.eq( 1, res[0]._id );
+assert( res[0].score > (res[1].score*2), tojson(res.toArray()));
+
+res = t.find( { "$text" : { "$search" : "write blog" } }, { score: { "$meta" : "textScore" } }  ).sort( { score: { "$meta" : "textScore" } });
+assert.eq( 3, res.length() );
+assert.eq( 1, res[0]._id );
+assert( res[0].score > (res[1].score*2), tojson(res.toArray()));
 
 
 
diff --git a/jstests/core/fts_proj.js b/jstests/core/fts_proj.js
index 1ecc6688d1b..ecd60e83a65 100644
--- a/jstests/core/fts_proj.js
+++ b/jstests/core/fts_proj.js
@@ -7,13 +7,13 @@ t.save( { _id : 3 , x : "a", y: "g", z : "h"});
 
 t.ensureIndex( { x : "text"} , { default_language : "none" } );
 
-res = t.runCommand("text", {search : "a"});
-assert.eq( 2, res.results.length );
-assert( res.results[0].obj.y, tojson(res) );
+res = t.find( { "$text": {"$search" : "a"}} );
+assert.eq( 2, res.length() );
+assert( res[0].y, tojson(res.toArray()));
 
-res = t.runCommand("text", {search : "a", project: {x: 1}});
-assert.eq( 2, res.results.length );
-assert( !res.results[0].obj.y, tojson(res) );
+res = t.find( { "$text": {"$search" : "a"}},  {x: 1} );
+assert.eq( 2, res.length() );
+assert( !res[0].y, tojson(res.toArray()));
 
 
 
diff --git a/jstests/core/fts_spanish.js b/jstests/core/fts_spanish.js
index b322c369f3f..7c8ccecd577 100644
--- a/jstests/core/fts_spanish.js
+++ b/jstests/core/fts_spanish.js
@@ -14,12 +14,12 @@ t.save( { _id: 4, language: "en", title: "My fourth blog", text: "This stemmed b
 t.ensureIndex( { "title": "text", text: "text" }, { weights: { title: 10 },
                                                     default_language: "es" } );
 
-res = t.runCommand( "text", { search: "blog" } );
-assert.eq( 4, res.results.length );
+res = t.find( { "$text" : { "$search" : "blog" } } );
+assert.eq( 4, res.length() );
 
 assert.eq( [4], queryIDS( t, "stem" ) );
 assert.eq( [3], queryIDS( t, "stemmed" ) );
-assert.eq( [4], queryIDS( t, "stemmed", null, { language : "en" } ) );
+assert.eq( [4], queryIDS( t, "stemmed", null, { "$language" : "en" } ) );
 
 assert.eq( [1,2], queryIDS( t, "prueba" ) );
 
-- 
cgit v1.2.1