test/view_server/query_server_spec.rb - couchdb - Git at Google

 # Licensed under the Apache License, Version 2.0 (the "License"); you may not
 # use this file except in compliance with the License. You may obtain a copy of
 # the License at
 #
 #   http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 # License for the specific language governing permissions and limitations under
 # the License.

 # to run (requires ruby and rspec):
 # rspec test/view_server/query_server_spec.rb
 #
 # environment options:
 #   QS_TRACE=true
 #     shows full output from the query server
 #   QS_LANG=lang
 #     run tests on the query server (for now, one of: js, erlang)
 #

 COUCH_ROOT = "#{File.dirname(__FILE__)}/../.." unless defined?(COUCH_ROOT)
 LANGUAGE = ENV["QS_LANG"] || "js"

 puts "Running query server specs for #{LANGUAGE} query server"

 require 'rspec'
 require 'json'

 class OSProcessRunner
   def self.run
     trace = ENV["QS_TRACE"] || false
     puts "launching #{run_command}" if trace
     if block_given?
       IO.popen(run_command, "r+") do |io|
         qs = QueryServerRunner.new(io, trace)
         yield qs
       end
     else
       io = IO.popen(run_command, "r+")
       QueryServerRunner.new(io, trace)
     end
   end
   def initialize io, trace = false
     @qsio = io
     @trace = trace
   end
   def close
     @qsio.close
   end
   def reset!
     run(["reset"])
   end
   def add_fun(fun)
     run(["add_fun", fun])
   end
   def teach_ddoc(ddoc)
     run(["ddoc", "new", ddoc_id(ddoc), ddoc])
   end
   def ddoc_run(ddoc, fun_path, args)
     run(["ddoc", ddoc_id(ddoc), fun_path, args])
   end
   def ddoc_id(ddoc)
     d_id = ddoc["_id"]
     raise 'ddoc must have _id' unless d_id
     d_id
   end
   def get_chunks
     resp = jsgets
     raise "not a chunk" unless resp.first == "chunks"
     return resp[1]
   end
   def run json
     rrun json
     jsgets
   end
   def rrun json
     line = json.to_json
     puts "run: #{line}" if @trace
     @qsio.puts line
   end
   def rgets
     resp = @qsio.gets
     puts "got: #{resp}"  if @trace
     resp
   end
   def jsgets
     resp = rgets
     # err = @qserr.gets
     # puts "err: #{err}" if err
     if resp
       begin
         rj = JSON.parse("[#{resp.chomp}]")[0]
       rescue JSON::ParserError
         puts "JSON ERROR (dump under trace mode)"
         # puts resp.chomp
         while resp = rgets
           # puts resp.chomp
         end
       end
       if rj.respond_to?(:[]) && rj.is_a?(Array)
         if rj[0] == "log"
           log = rj[1]
           puts "log: #{log}" if @trace
           rj = jsgets
         end
       end
       rj
     else
       raise "no response"
     end
   end
 end

 class QueryServerRunner < OSProcessRunner

   COMMANDS = {
     "js" => "#{COUCH_ROOT}/bin/couchjs #{COUCH_ROOT}/share/server/main.js",
     "erlang" => "#{COUCH_ROOT}/test/view_server/run_native_process.es"
   }

   def self.run_command
     COMMANDS[LANGUAGE]
   end
 end

 class ExternalRunner < OSProcessRunner
   def self.run_command
     "#{COUCH_ROOT}/src/couchdb/couchjs #{COUCH_ROOT}/share/server/echo.js"
   end
 end

 # we could organize this into a design document per language.
 # that would make testing future languages really easy.

 functions = {
   "emit-twice" => {
     "js" => %{function(doc){emit("foo",doc.a); emit("bar",doc.a)}},
     "erlang" => <<-ERLANG
       fun({Doc}) ->
         A = couch_util:get_value(<<"a">>, Doc, null),
         Emit(<<"foo">>, A),
         Emit(<<"bar">>, A)
       end.
     ERLANG
   },
   "emit-once" => {
     "js" => <<-JS,
       function(doc){
         emit("baz",doc.a)
       }
       JS
     "erlang" => <<-ERLANG
         fun({Doc}) ->
             A = couch_util:get_value(<<"a">>, Doc, null),
             Emit(<<"baz">>, A)
         end.
     ERLANG
   },
   "reduce-values-length" => {
     "js" => %{function(keys, values, rereduce) { return values.length; }},
     "erlang" => %{fun(Keys, Values, ReReduce) -> length(Values) end.}
   },
   "reduce-values-sum" => {
     "js" => %{function(keys, values, rereduce) { return sum(values); }},
     "erlang" => %{fun(Keys, Values, ReReduce) -> lists:sum(Values) end.}
   },
   "validate-forbidden" => {
     "js" => <<-JS,
       function(newDoc, oldDoc, userCtx) {
         if(newDoc.bad)
           throw({forbidden:"bad doc"}); "foo bar";
       }
       JS
     "erlang" => <<-ERLANG
       fun({NewDoc}, _OldDoc, _UserCtx) ->
         case couch_util:get_value(<<"bad">>, NewDoc) of
             undefined -> 1;
             _ -> {[{forbidden, <<"bad doc">>}]}
         end
       end.
     ERLANG
   },
   "show-simple" => {
     "js" => <<-JS,
         function(doc, req) {
             log("ok");
             return [doc.title, doc.body].join(' - ');
         }
     JS
     "erlang" => <<-ERLANG
       fun({Doc}, Req) ->
             Title = couch_util:get_value(<<"title">>, Doc),
             Body = couch_util:get_value(<<"body">>, Doc),
             Resp = <<Title/binary, " - ", Body/binary>>,
         {[{<<"body">>, Resp}]}
       end.
     ERLANG
   },
   "show-headers" => {
     "js" => <<-JS,
         function(doc, req) {
           var resp = {"code":200, "headers":{"X-Plankton":"Rusty"}};
           resp.body = [doc.title, doc.body].join(' - ');
           return resp;
         }
      JS
     "erlang" => <<-ERLANG
   fun({Doc}, Req) ->
         Title = couch_util:get_value(<<"title">>, Doc),
         Body = couch_util:get_value(<<"body">>, Doc),
         Resp = <<Title/binary, " - ", Body/binary>>,
         {[
         {<<"code">>, 200},
         {<<"headers">>, {[{<<"X-Plankton">>, <<"Rusty">>}]}},
         {<<"body">>, Resp}
       ]}
   end.
     ERLANG
   },
   "show-sends" => {
     "js" =>  <<-JS,
         function(head, req) {
           start({headers:{"Content-Type" : "text/plain"}});
           send("first chunk");
           send('second "chunk"');
           return "tail";
         };
     JS
     "erlang" => <<-ERLANG
       fun(Head, Req) ->
         Resp = {[
           {<<"headers">>, {[{<<"Content-Type">>, <<"text/plain">>}]}}
         ]},
         Start(Resp),
         Send(<<"first chunk">>),
         Send(<<"second \\\"chunk\\\"">>),
         <<"tail">>
       end.
     ERLANG
   },
   "show-while-get-rows" => {
     "js" =>  <<-JS,
         function(head, req) {
           send("first chunk");
           send(req.q);
           var row;
           log("about to getRow " + typeof(getRow));
           while(row = getRow()) {
             send(row.key);
           };
           return "tail";
         };
     JS
     "erlang" => <<-ERLANG,
         fun(Head, {Req}) ->
             Send(<<"first chunk">>),
             Send(couch_util:get_value(<<"q">>, Req)),
             Fun = fun({Row}, _) ->
                 Send(couch_util:get_value(<<"key">>, Row)),
                 {ok, nil}
             end,
             {ok, _} = FoldRows(Fun, nil),
             <<"tail">>
         end.
     ERLANG
   },
   "show-while-get-rows-multi-send" => {
     "js" => <<-JS,
         function(head, req) {
           send("bacon");
           var row;
           log("about to getRow " + typeof(getRow));
           while(row = getRow()) {
             send(row.key);
             send("eggs");
           };
           return "tail";
         };
     JS
     "erlang" => <<-ERLANG,
         fun(Head, Req) ->
             Send(<<"bacon">>),
             Fun = fun({Row}, _) ->
                 Send(couch_util:get_value(<<"key">>, Row)),
                 Send(<<"eggs">>),
                 {ok, nil}
             end,
             FoldRows(Fun, nil),
             <<"tail">>
         end.
     ERLANG
   },
   "list-simple" => {
     "js" => <<-JS,
         function(head, req) {
           send("first chunk");
           send(req.q);
           var row;
           while(row = getRow()) {
             send(row.key);
           };
           return "early";
         };
     JS
     "erlang" => <<-ERLANG,
         fun(Head, {Req}) ->
             Send(<<"first chunk">>),
             Send(couch_util:get_value(<<"q">>, Req)),
             Fun = fun({Row}, _) ->
                 Send(couch_util:get_value(<<"key">>, Row)),
                 {ok, nil}
             end,
             FoldRows(Fun, nil),
             <<"early">>
         end.
     ERLANG
   },
   "list-chunky" => {
     "js" => <<-JS,
         function(head, req) {
           send("first chunk");
           send(req.q);
           var row, i=0;
           while(row = getRow()) {
             send(row.key);
             i += 1;
             if (i > 2) {
               return('early tail');
             }
           };
         };
     JS
     "erlang" => <<-ERLANG,
         fun(Head, {Req}) ->
             Send(<<"first chunk">>),
             Send(couch_util:get_value(<<"q">>, Req)),
             Fun = fun
                 ({Row}, Count) when Count < 2 ->
                     Send(couch_util:get_value(<<"key">>, Row)),
                     {ok, Count+1};
                 ({Row}, Count) when Count == 2 ->
                     Send(couch_util:get_value(<<"key">>, Row)),
                     {stop, <<"early tail">>}
             end,
             {ok, Tail} = FoldRows(Fun, 0),
             Tail
         end.
     ERLANG
   },
   "list-old-style" => {
     "js" => <<-JS,
         function(head, req, foo, bar) {
           return "stuff";
         }
     JS
     "erlang" => <<-ERLANG,
         fun(Head, Req, Foo, Bar) ->
             <<"stuff">>
         end.
     ERLANG
   },
   "list-capped" => {
     "js" => <<-JS,
         function(head, req) {
           send("bacon")
           var row, i = 0;
           while(row = getRow()) {
             send(row.key);
             i += 1;
             if (i > 2) {
               return('early');
             }
           };
         }
     JS
     "erlang" => <<-ERLANG,
         fun(Head, Req) ->
             Send(<<"bacon">>),
             Fun = fun
                 ({Row}, Count) when Count < 2 ->
                     Send(couch_util:get_value(<<"key">>, Row)),
                     {ok, Count+1};
                 ({Row}, Count) when Count == 2 ->
                     Send(couch_util:get_value(<<"key">>, Row)),
                     {stop, <<"early">>}
             end,
             {ok, Tail} = FoldRows(Fun, 0),
             Tail
         end.
     ERLANG
   },
   "list-raw" => {
     "js" => <<-JS,
         function(head, req) {
           // log(this.toSource());
           // log(typeof send);
           send("first chunk");
           send(req.q);
           var row;
           while(row = getRow()) {
             send(row.key);
           };
           return "tail";
         };
     JS
     "erlang" => <<-ERLANG,
         fun(Head, {Req}) ->
             Send(<<"first chunk">>),
             Send(couch_util:get_value(<<"q">>, Req)),
             Fun = fun({Row}, _) ->
                 Send(couch_util:get_value(<<"key">>, Row)),
                 {ok, nil}
             end,
             FoldRows(Fun, nil),
             <<"tail">>
         end.
     ERLANG
   },
   "filter-basic" => {
     "js" => <<-JS,
       function(doc, req) {
         if (doc.good) {
           return true;
         }
       }
     JS
     "erlang" => <<-ERLANG,
         fun({Doc}, Req) ->
             couch_util:get_value(<<"good">>, Doc)
         end.
     ERLANG
   },
   "update-basic" => {
     "js" => <<-JS,
     function(doc, req) {
       doc.world = "hello";
       var resp = [doc, "hello doc"];
       return resp;
     }
     JS
     "erlang" => <<-ERLANG,
         fun({Doc}, Req) ->
             Doc2 = [{<<"world">>, <<"hello">>}|Doc],
             [{Doc2}, {[{<<"body">>, <<"hello doc">>}]}]
         end.
     ERLANG
   },
   "rewrite-basic" => {
     "js" => <<-JS,
     function(req) {
       return "new/location";
     }
     JS
     "erlang" => <<-ERLANG,
         fun(Req) ->
             {[{"path", "new/location"}]}
         end.
     ERLANG
   },
   "rewrite-no-rule" => {
     "js" => <<-JS,
     function(req) {
       return;
     }
     JS
     "erlang" => <<-ERLANG,
         fun(Req) ->
             undefined
         end.
     ERLANG
   },
   "error" => {
     "js" => <<-JS,
     function() {
       throw(["error","error_key","testing"]);
     }
     JS
     "erlang" => <<-ERLANG
     fun(A, B) ->
       throw([<<"error">>,<<"error_key">>,<<"testing">>])
     end.
     ERLANG
   },
   "fatal" => {
     "js" => <<-JS,
     function() {
       throw(["fatal","error_key","testing"]);
     }
     JS
     "erlang" => <<-ERLANG
     fun(A, B) ->
       throw([<<"fatal">>,<<"error_key">>,<<"testing">>])
     end.
     ERLANG
   }
 }

 def make_ddoc(fun_path, fun_str)
   doc = {"_id"=>"foo"}
   d = doc
   while p = fun_path.shift
     l = p
     if !fun_path.empty?
       d[p] = {}
       d = d[p]
     end
   end
   d[l] = fun_str
   doc
 end

 describe "query server normal case" do
   before(:all) do
     `cd #{COUCH_ROOT} && make`
     @qs = QueryServerRunner.run
   end
   after(:all) do
     @qs.close
   end
   it "should reset" do
     @qs.run(["reset"]).should == true
   end
   it "should not erase ddocs on reset" do
     @fun = functions["show-simple"][LANGUAGE]
     @ddoc = make_ddoc(["shows","simple"], @fun)
     @qs.teach_ddoc(@ddoc)
     @qs.run(["reset"]).should == true
     @qs.ddoc_run(@ddoc,
       ["shows","simple"],
       [{:title => "Best ever", :body => "Doc body"}, {}]).should ==
     ["resp", {"body" => "Best ever - Doc body"}]
   end

   it "should run map funs" do
     @qs.reset!
     @qs.run(["add_fun", functions["emit-twice"][LANGUAGE]]).should == true
     @qs.run(["add_fun", functions["emit-once"][LANGUAGE]]).should == true
     rows = @qs.run(["map_doc", {:a => "b"}])
     rows[0][0].should == ["foo", "b"]
     rows[0][1].should == ["bar", "b"]
     rows[1][0].should == ["baz", "b"]
   end
   describe "reduce" do
     before(:all) do
       @fun = functions["reduce-values-length"][LANGUAGE]
       @qs.reset!
     end
     it "should reduce" do
       kvs = (0...10).collect{|i|[i,i*2]}
       @qs.run(["reduce", [@fun], kvs]).should == [true, [10]]
     end
   end
   describe "rereduce" do
     before(:all) do
       @fun = functions["reduce-values-sum"][LANGUAGE]
       @qs.reset!
     end
     it "should rereduce" do
       vs = (0...10).collect{|i|i}
       @qs.run(["rereduce", [@fun], vs]).should == [true, [45]]
     end
   end

   describe "design docs" do
     before(:all) do
       @ddoc = {
         "_id" => "foo"
       }
       @qs.reset!
     end
     it "should learn design docs" do
       @qs.teach_ddoc(@ddoc).should == true
     end
   end

   # it "should validate"
   describe "validation" do
     before(:all) do
       @fun = functions["validate-forbidden"][LANGUAGE]
       @ddoc = make_ddoc(["validate_doc_update"], @fun)
       @qs.teach_ddoc(@ddoc)
     end
     it "should allow good updates" do
       @qs.ddoc_run(@ddoc,
         ["validate_doc_update"],
         [{"good" => true}, {}, {}]).should == 1
     end
     it "should reject invalid updates" do
       @qs.ddoc_run(@ddoc,
         ["validate_doc_update"],
         [{"bad" => true}, {}, {}]).should == {"forbidden"=>"bad doc"}
     end
   end

   describe "show" do
     before(:all) do
       @fun = functions["show-simple"][LANGUAGE]
       @ddoc = make_ddoc(["shows","simple"], @fun)
       @qs.teach_ddoc(@ddoc)
     end
     it "should show" do
       @qs.ddoc_run(@ddoc,
         ["shows","simple"],
         [{:title => "Best ever", :body => "Doc body"}, {}]).should ==
       ["resp", {"body" => "Best ever - Doc body"}]
     end
   end

   describe "show with headers" do
     before(:all) do
       # TODO we can make real ddocs up there.
       @fun = functions["show-headers"][LANGUAGE]
       @ddoc = make_ddoc(["shows","headers"], @fun)
       @qs.teach_ddoc(@ddoc)
     end
     it "should show headers" do
       @qs.ddoc_run(
         @ddoc,
         ["shows","headers"],
         [{:title => "Best ever", :body => "Doc body"}, {}]
       ).
       should == ["resp", {"code"=>200,"headers" => {"X-Plankton"=>"Rusty"}, "body" => "Best ever - Doc body"}]
     end
   end

   describe "recoverable error" do
     before(:all) do
       @fun = functions["error"][LANGUAGE]
       @ddoc = make_ddoc(["shows","error"], @fun)
       @qs.teach_ddoc(@ddoc)
     end
     it "should not exit" do
       @qs.ddoc_run(@ddoc, ["shows","error"],
         [{"foo"=>"bar"}, {"q" => "ok"}]).
         should == ["error", "error_key", "testing"]
       # still running
       @qs.run(["reset"]).should == true
     end
   end

   describe "changes filter" do
     before(:all) do
       @fun = functions["filter-basic"][LANGUAGE]
       @ddoc = make_ddoc(["filters","basic"], @fun)
       @qs.teach_ddoc(@ddoc)
     end
     it "should only return true for good docs" do
       @qs.ddoc_run(@ddoc,
         ["filters","basic"],
         [[{"key"=>"bam", "good" => true}, {"foo" => "bar"}, {"good" => true}], {"req" => "foo"}]
       ).
       should == [true, [true, false, true]]
     end
   end

   describe "update" do
     before(:all) do
       # in another patch we can remove this duplication
       # by setting up the design doc for each language ahead of time.
       @fun = functions["update-basic"][LANGUAGE]
       @ddoc = make_ddoc(["updates","basic"], @fun)
       @qs.teach_ddoc(@ddoc)
     end
     it "should return a doc and a resp body" do
       up, doc, resp = @qs.ddoc_run(@ddoc,
         ["updates","basic"],
         [{"foo" => "gnarly"}, {"method" => "POST"}]
       )
       up.should == "up"
       doc.should == {"foo" => "gnarly", "world" => "hello"}
       resp["body"].should == "hello doc"
     end
   end

 # end
 #                    LIST TESTS
 # __END__

   describe "ddoc list" do
       before(:all) do
         @ddoc = {
           "_id" => "foo",
           "lists" => {
             "simple" => functions["list-simple"][LANGUAGE],
             "headers" => functions["show-sends"][LANGUAGE],
             "rows" => functions["show-while-get-rows"][LANGUAGE],
             "buffer-chunks" => functions["show-while-get-rows-multi-send"][LANGUAGE],
             "chunky" => functions["list-chunky"][LANGUAGE]
           }
         }
         @qs.teach_ddoc(@ddoc)
       end

       describe "example list" do
         it "should run normal" do
           @qs.ddoc_run(@ddoc,
             ["lists","simple"],
             [{"foo"=>"bar"}, {"q" => "ok"}]
           ).should == ["start", ["first chunk", "ok"], {"headers"=>{}}]
           @qs.run(["list_row", {"key"=>"baz"}]).should ==  ["chunks", ["baz"]]
           @qs.run(["list_row", {"key"=>"bam"}]).should ==  ["chunks", ["bam"]]
           @qs.run(["list_row", {"key"=>"foom"}]).should == ["chunks", ["foom"]]
           @qs.run(["list_row", {"key"=>"fooz"}]).should == ["chunks", ["fooz"]]
           @qs.run(["list_row", {"key"=>"foox"}]).should == ["chunks", ["foox"]]
           @qs.run(["list_end"]).should == ["end" , ["early"]]
         end
       end

       describe "headers" do
         it "should do headers proper" do
           @qs.ddoc_run(@ddoc, ["lists","headers"],
             [{"total_rows"=>1000}, {"q" => "ok"}]
           ).should == ["start", ["first chunk", 'second "chunk"'],
             {"headers"=>{"Content-Type"=>"text/plain"}}]
           @qs.rrun(["list_end"])
           @qs.jsgets.should == ["end", ["tail"]]
         end
       end

       describe "with rows" do
         it "should list em" do
           @qs.ddoc_run(@ddoc, ["lists","rows"],
             [{"foo"=>"bar"}, {"q" => "ok"}]).
             should == ["start", ["first chunk", "ok"], {"headers"=>{}}]
           @qs.rrun(["list_row", {"key"=>"baz"}])
           @qs.get_chunks.should == ["baz"]
           @qs.rrun(["list_row", {"key"=>"bam"}])
           @qs.get_chunks.should == ["bam"]
           @qs.rrun(["list_end"])
           @qs.jsgets.should == ["end", ["tail"]]
         end
         it "should work with zero rows" do
           @qs.ddoc_run(@ddoc, ["lists","rows"],
             [{"foo"=>"bar"}, {"q" => "ok"}]).
             should == ["start", ["first chunk", "ok"], {"headers"=>{}}]
           @qs.rrun(["list_end"])
           @qs.jsgets.should == ["end", ["tail"]]
         end
       end

       describe "should buffer multiple chunks sent for a single row." do
         it "should should buffer em" do
           @qs.ddoc_run(@ddoc, ["lists","buffer-chunks"],
             [{"foo"=>"bar"}, {"q" => "ok"}]).
             should == ["start", ["bacon"], {"headers"=>{}}]
           @qs.rrun(["list_row", {"key"=>"baz"}])
           @qs.get_chunks.should == ["baz", "eggs"]
           @qs.rrun(["list_row", {"key"=>"bam"}])
           @qs.get_chunks.should == ["bam", "eggs"]
           @qs.rrun(["list_end"])
           @qs.jsgets.should == ["end", ["tail"]]
         end
       end
       it "should end after 2" do
         @qs.ddoc_run(@ddoc, ["lists","chunky"],
           [{"foo"=>"bar"}, {"q" => "ok"}]).
           should == ["start", ["first chunk", "ok"], {"headers"=>{}}]

         @qs.run(["list_row", {"key"=>"baz"}]).
           should ==  ["chunks", ["baz"]]

         @qs.run(["list_row", {"key"=>"bam"}]).
           should ==  ["chunks", ["bam"]]

         @qs.run(["list_row", {"key"=>"foom"}]).
           should == ["end", ["foom", "early tail"]]
         # here's where js has to discard quit properly
         @qs.run(["reset"]).
           should == true
       end
     end

   describe "ddoc rewrites" do
     describe "simple rewrite" do
       before(:all) do
         @ddoc = {
           "_id" => "foo",
           "rewrites" => functions["rewrite-basic"][LANGUAGE]
         }
         @qs.teach_ddoc(@ddoc)
       end
       it "should run normal" do
         ok, resp = @qs.ddoc_run(@ddoc,
           ["rewrites"],
           [{"path" => "foo/bar"}, {"method" => "POST"}]
         )
         ok.should == "ok"
         resp["path"].should == "new/location"
       end
     end

     describe "no rule" do
       before(:all) do
         @ddoc = {
           "_id" => "foo",
           "rewrites" => functions["rewrite-no-rule"][LANGUAGE]
         }
         @qs.teach_ddoc(@ddoc)
       end
       it "should run normal" do
         resp = @qs.ddoc_run(@ddoc,
           ["rewrites"],
           [{"path" => "foo/bar"}, {"method" => "POST"}]
         )
         resp.should == ['no_dispatch_rule']
       end
     end
   end
 end


 def should_have_exited qs
   begin
     qs.run(["reset"])
     "raise before this (except Erlang)".should == true
   rescue RuntimeError => e
     e.message.should == "no response"
   rescue Errno::EPIPE
     true.should == true
   end
 end

 describe "query server that exits" do
   before(:each) do
     @qs = QueryServerRunner.run
     @ddoc = {
       "_id" => "foo",
       "lists" => {
         "capped" => functions["list-capped"][LANGUAGE],
         "raw" => functions["list-raw"][LANGUAGE]
       },
       "shows" => {
         "fatal" => functions["fatal"][LANGUAGE]
       }
     }
     @qs.teach_ddoc(@ddoc)
   end
   after(:each) do
     @qs.close
   end

   describe "only goes to 2 list" do
     it "should exit if erlang sends too many rows" do
       @qs.ddoc_run(@ddoc, ["lists","capped"],
         [{"foo"=>"bar"}, {"q" => "ok"}]).
         should == ["start", ["bacon"], {"headers"=>{}}]
       @qs.run(["list_row", {"key"=>"baz"}]).should ==  ["chunks", ["baz"]]
       @qs.run(["list_row", {"key"=>"foom"}]).should == ["chunks", ["foom"]]
       @qs.run(["list_row", {"key"=>"fooz"}]).should == ["end", ["fooz", "early"]]
       e = @qs.run(["list_row", {"key"=>"foox"}])
       e[0].should == "error"
       e[1].should == "unknown_command"
       should_have_exited @qs
     end
   end

   describe "raw list" do
     it "should exit if it gets a non-row in the middle" do
       @qs.ddoc_run(@ddoc, ["lists","raw"],
         [{"foo"=>"bar"}, {"q" => "ok"}]).
         should == ["start", ["first chunk", "ok"], {"headers"=>{}}]
       e = @qs.run(["reset"])
       e[0].should == "error"
       e[1].should == "list_error"
       should_have_exited @qs
     end
   end

   describe "fatal error" do
     it "should exit" do
       @qs.ddoc_run(@ddoc, ["shows","fatal"],
         [{"foo"=>"bar"}, {"q" => "ok"}]).
         should == ["error", "error_key", "testing"]
       should_have_exited @qs
     end
   end
 end

 describe "thank you for using the tests" do
   it "for more info run with QS_TRACE=true or see query_server_spec.rb file header" do
   end
 end
	# Licensed under the Apache License, Version 2.0 (the "License"); you may not
	# use this file except in compliance with the License. You may obtain a copy of
	# the License at
	#
	# http://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	# License for the specific language governing permissions and limitations under
	# the License.

	# to run (requires ruby and rspec):
	# rspec test/view_server/query_server_spec.rb
	#
	# environment options:
	# QS_TRACE=true
	# shows full output from the query server
	# QS_LANG=lang
	# run tests on the query server (for now, one of: js, erlang)
	#

	COUCH_ROOT = "#{File.dirname(__FILE__)}/../.." unless defined?(COUCH_ROOT)
	LANGUAGE = ENV["QS_LANG"] \|\| "js"

	puts "Running query server specs for #{LANGUAGE} query server"

	require 'rspec'
	require 'json'

	class OSProcessRunner
	def self.run
	trace = ENV["QS_TRACE"] \|\| false
	puts "launching #{run_command}" if trace
	if block_given?
	IO.popen(run_command, "r+") do \|io\|
	qs = QueryServerRunner.new(io, trace)
	yield qs
	end
	else
	io = IO.popen(run_command, "r+")
	QueryServerRunner.new(io, trace)
	end
	end
	def initialize io, trace = false
	@qsio = io
	@trace = trace
	end
	def close
	@qsio.close
	end
	def reset!
	run(["reset"])
	end
	def add_fun(fun)
	run(["add_fun", fun])
	end
	def teach_ddoc(ddoc)
	run(["ddoc", "new", ddoc_id(ddoc), ddoc])
	end
	def ddoc_run(ddoc, fun_path, args)
	run(["ddoc", ddoc_id(ddoc), fun_path, args])
	end
	def ddoc_id(ddoc)
	d_id = ddoc["_id"]
	raise 'ddoc must have _id' unless d_id
	d_id
	end
	def get_chunks
	resp = jsgets
	raise "not a chunk" unless resp.first == "chunks"
	return resp[1]
	end
	def run json
	rrun json
	jsgets
	end
	def rrun json
	line = json.to_json
	puts "run: #{line}" if @trace
	@qsio.puts line
	end
	def rgets
	resp = @qsio.gets
	puts "got: #{resp}" if @trace
	resp
	end
	def jsgets
	resp = rgets
	# err = @qserr.gets
	# puts "err: #{err}" if err
	if resp
	begin
	rj = JSON.parse("[#{resp.chomp}]")[0]
	rescue JSON::ParserError
	puts "JSON ERROR (dump under trace mode)"
	# puts resp.chomp
	while resp = rgets
	# puts resp.chomp
	end
	end
	if rj.respond_to?(:[]) && rj.is_a?(Array)
	if rj[0] == "log"
	log = rj[1]
	puts "log: #{log}" if @trace
	rj = jsgets
	end
	end
	rj
	else
	raise "no response"
	end
	end
	end

	class QueryServerRunner < OSProcessRunner

	COMMANDS = {
	"js" => "#{COUCH_ROOT}/bin/couchjs #{COUCH_ROOT}/share/server/main.js",
	"erlang" => "#{COUCH_ROOT}/test/view_server/run_native_process.es"
	}

	def self.run_command
	COMMANDS[LANGUAGE]
	end
	end

	class ExternalRunner < OSProcessRunner
	def self.run_command
	"#{COUCH_ROOT}/src/couchdb/couchjs #{COUCH_ROOT}/share/server/echo.js"
	end
	end

	# we could organize this into a design document per language.
	# that would make testing future languages really easy.

	functions = {
	"emit-twice" => {
	"js" => %{function(doc){emit("foo",doc.a); emit("bar",doc.a)}},
	"erlang" => <<-ERLANG
	fun({Doc}) ->
	A = couch_util:get_value(<<"a">>, Doc, null),
	Emit(<<"foo">>, A),
	Emit(<<"bar">>, A)
	end.
	ERLANG
	},
	"emit-once" => {
	"js" => <<-JS,
	function(doc){
	emit("baz",doc.a)
	}
	JS
	"erlang" => <<-ERLANG
	fun({Doc}) ->
	A = couch_util:get_value(<<"a">>, Doc, null),
	Emit(<<"baz">>, A)
	end.
	ERLANG
	},
	"reduce-values-length" => {
	"js" => %{function(keys, values, rereduce) { return values.length; }},
	"erlang" => %{fun(Keys, Values, ReReduce) -> length(Values) end.}
	},
	"reduce-values-sum" => {
	"js" => %{function(keys, values, rereduce) { return sum(values); }},
	"erlang" => %{fun(Keys, Values, ReReduce) -> lists:sum(Values) end.}
	},
	"validate-forbidden" => {
	"js" => <<-JS,
	function(newDoc, oldDoc, userCtx) {
	if(newDoc.bad)
	throw({forbidden:"bad doc"}); "foo bar";
	}
	JS
	"erlang" => <<-ERLANG
	fun({NewDoc}, _OldDoc, _UserCtx) ->
	case couch_util:get_value(<<"bad">>, NewDoc) of
	undefined -> 1;
	_ -> {[{forbidden, <<"bad doc">>}]}
	end
	end.
	ERLANG
	},
	"show-simple" => {
	"js" => <<-JS,
	function(doc, req) {
	log("ok");
	return [doc.title, doc.body].join(' - ');
	}
	JS
	"erlang" => <<-ERLANG
	fun({Doc}, Req) ->
	Title = couch_util:get_value(<<"title">>, Doc),
	Body = couch_util:get_value(<<"body">>, Doc),
	Resp = <<Title/binary, " - ", Body/binary>>,
	{[{<<"body">>, Resp}]}
	end.
	ERLANG
	},
	"show-headers" => {
	"js" => <<-JS,
	function(doc, req) {
	var resp = {"code":200, "headers":{"X-Plankton":"Rusty"}};
	resp.body = [doc.title, doc.body].join(' - ');
	return resp;
	}
	JS
	"erlang" => <<-ERLANG
	fun({Doc}, Req) ->
	Title = couch_util:get_value(<<"title">>, Doc),
	Body = couch_util:get_value(<<"body">>, Doc),
	Resp = <<Title/binary, " - ", Body/binary>>,
	{[
	{<<"code">>, 200},
	{<<"headers">>, {[{<<"X-Plankton">>, <<"Rusty">>}]}},
	{<<"body">>, Resp}
	]}
	end.
	ERLANG
	},
	"show-sends" => {
	"js" => <<-JS,
	function(head, req) {
	start({headers:{"Content-Type" : "text/plain"}});
	send("first chunk");
	send('second "chunk"');
	return "tail";
	};
	JS
	"erlang" => <<-ERLANG
	fun(Head, Req) ->
	Resp = {[
	{<<"headers">>, {[{<<"Content-Type">>, <<"text/plain">>}]}}
	]},
	Start(Resp),
	Send(<<"first chunk">>),
	Send(<<"second \\\"chunk\\\"">>),
	<<"tail">>
	end.
	ERLANG
	},
	"show-while-get-rows" => {
	"js" => <<-JS,
	function(head, req) {
	send("first chunk");
	send(req.q);
	var row;
	log("about to getRow " + typeof(getRow));
	while(row = getRow()) {
	send(row.key);
	};
	return "tail";
	};
	JS
	"erlang" => <<-ERLANG,
	fun(Head, {Req}) ->
	Send(<<"first chunk">>),
	Send(couch_util:get_value(<<"q">>, Req)),
	Fun = fun({Row}, _) ->
	Send(couch_util:get_value(<<"key">>, Row)),
	{ok, nil}
	end,
	{ok, _} = FoldRows(Fun, nil),
	<<"tail">>
	end.
	ERLANG
	},
	"show-while-get-rows-multi-send" => {
	"js" => <<-JS,
	function(head, req) {
	send("bacon");
	var row;
	log("about to getRow " + typeof(getRow));
	while(row = getRow()) {
	send(row.key);
	send("eggs");
	};
	return "tail";
	};
	JS
	"erlang" => <<-ERLANG,
	fun(Head, Req) ->
	Send(<<"bacon">>),
	Fun = fun({Row}, _) ->
	Send(couch_util:get_value(<<"key">>, Row)),
	Send(<<"eggs">>),
	{ok, nil}
	end,
	FoldRows(Fun, nil),
	<<"tail">>
	end.
	ERLANG
	},
	"list-simple" => {
	"js" => <<-JS,
	function(head, req) {
	send("first chunk");
	send(req.q);
	var row;
	while(row = getRow()) {
	send(row.key);
	};
	return "early";
	};
	JS
	"erlang" => <<-ERLANG,
	fun(Head, {Req}) ->
	Send(<<"first chunk">>),
	Send(couch_util:get_value(<<"q">>, Req)),
	Fun = fun({Row}, _) ->
	Send(couch_util:get_value(<<"key">>, Row)),
	{ok, nil}
	end,
	FoldRows(Fun, nil),
	<<"early">>
	end.
	ERLANG
	},
	"list-chunky" => {
	"js" => <<-JS,
	function(head, req) {
	send("first chunk");
	send(req.q);
	var row, i=0;
	while(row = getRow()) {
	send(row.key);
	i += 1;
	if (i > 2) {
	return('early tail');
	}
	};
	};
	JS
	"erlang" => <<-ERLANG,
	fun(Head, {Req}) ->
	Send(<<"first chunk">>),
	Send(couch_util:get_value(<<"q">>, Req)),
	Fun = fun
	({Row}, Count) when Count < 2 ->
	Send(couch_util:get_value(<<"key">>, Row)),
	{ok, Count+1};
	({Row}, Count) when Count == 2 ->
	Send(couch_util:get_value(<<"key">>, Row)),
	{stop, <<"early tail">>}
	end,
	{ok, Tail} = FoldRows(Fun, 0),
	Tail
	end.
	ERLANG
	},
	"list-old-style" => {
	"js" => <<-JS,
	function(head, req, foo, bar) {
	return "stuff";
	}
	JS
	"erlang" => <<-ERLANG,
	fun(Head, Req, Foo, Bar) ->
	<<"stuff">>
	end.
	ERLANG
	},
	"list-capped" => {
	"js" => <<-JS,
	function(head, req) {
	send("bacon")
	var row, i = 0;
	while(row = getRow()) {
	send(row.key);
	i += 1;
	if (i > 2) {
	return('early');
	}
	};
	}
	JS
	"erlang" => <<-ERLANG,
	fun(Head, Req) ->
	Send(<<"bacon">>),
	Fun = fun
	({Row}, Count) when Count < 2 ->
	Send(couch_util:get_value(<<"key">>, Row)),
	{ok, Count+1};
	({Row}, Count) when Count == 2 ->
	Send(couch_util:get_value(<<"key">>, Row)),
	{stop, <<"early">>}
	end,
	{ok, Tail} = FoldRows(Fun, 0),
	Tail
	end.
	ERLANG
	},
	"list-raw" => {
	"js" => <<-JS,
	function(head, req) {
	// log(this.toSource());
	// log(typeof send);
	send("first chunk");
	send(req.q);
	var row;
	while(row = getRow()) {
	send(row.key);
	};
	return "tail";
	};
	JS
	"erlang" => <<-ERLANG,
	fun(Head, {Req}) ->
	Send(<<"first chunk">>),
	Send(couch_util:get_value(<<"q">>, Req)),
	Fun = fun({Row}, _) ->
	Send(couch_util:get_value(<<"key">>, Row)),
	{ok, nil}
	end,
	FoldRows(Fun, nil),
	<<"tail">>
	end.
	ERLANG
	},
	"filter-basic" => {
	"js" => <<-JS,
	function(doc, req) {
	if (doc.good) {
	return true;
	}
	}
	JS
	"erlang" => <<-ERLANG,
	fun({Doc}, Req) ->
	couch_util:get_value(<<"good">>, Doc)
	end.
	ERLANG
	},
	"update-basic" => {
	"js" => <<-JS,
	function(doc, req) {
	doc.world = "hello";
	var resp = [doc, "hello doc"];
	return resp;
	}
	JS
	"erlang" => <<-ERLANG,
	fun({Doc}, Req) ->
	Doc2 = [{<<"world">>, <<"hello">>}\|Doc],
	[{Doc2}, {[{<<"body">>, <<"hello doc">>}]}]
	end.
	ERLANG
	},
	"rewrite-basic" => {
	"js" => <<-JS,
	function(req) {
	return "new/location";
	}
	JS
	"erlang" => <<-ERLANG,
	fun(Req) ->
	{[{"path", "new/location"}]}
	end.
	ERLANG
	},
	"rewrite-no-rule" => {
	"js" => <<-JS,
	function(req) {
	return;
	}
	JS
	"erlang" => <<-ERLANG,
	fun(Req) ->
	undefined
	end.
	ERLANG
	},
	"error" => {
	"js" => <<-JS,
	function() {
	throw(["error","error_key","testing"]);
	}
	JS
	"erlang" => <<-ERLANG
	fun(A, B) ->
	throw([<<"error">>,<<"error_key">>,<<"testing">>])
	end.
	ERLANG
	},
	"fatal" => {
	"js" => <<-JS,
	function() {
	throw(["fatal","error_key","testing"]);
	}
	JS
	"erlang" => <<-ERLANG
	fun(A, B) ->
	throw([<<"fatal">>,<<"error_key">>,<<"testing">>])
	end.
	ERLANG
	}
	}

	def make_ddoc(fun_path, fun_str)
	doc = {"_id"=>"foo"}
	d = doc
	while p = fun_path.shift
	l = p
	if !fun_path.empty?
	d[p] = {}
	d = d[p]
	end
	end
	d[l] = fun_str
	doc
	end

	describe "query server normal case" do
	before(:all) do
	`cd #{COUCH_ROOT} && make`
	@qs = QueryServerRunner.run
	end
	after(:all) do
	@qs.close
	end
	it "should reset" do
	@qs.run(["reset"]).should == true
	end
	it "should not erase ddocs on reset" do
	@fun = functions["show-simple"][LANGUAGE]
	@ddoc = make_ddoc(["shows","simple"], @fun)
	@qs.teach_ddoc(@ddoc)
	@qs.run(["reset"]).should == true
	@qs.ddoc_run(@ddoc,
	["shows","simple"],
	[{:title => "Best ever", :body => "Doc body"}, {}]).should ==
	["resp", {"body" => "Best ever - Doc body"}]
	end

	it "should run map funs" do
	@qs.reset!
	@qs.run(["add_fun", functions["emit-twice"][LANGUAGE]]).should == true
	@qs.run(["add_fun", functions["emit-once"][LANGUAGE]]).should == true
	rows = @qs.run(["map_doc", {:a => "b"}])
	rows[0][0].should == ["foo", "b"]
	rows[0][1].should == ["bar", "b"]
	rows[1][0].should == ["baz", "b"]
	end
	describe "reduce" do
	before(:all) do
	@fun = functions["reduce-values-length"][LANGUAGE]
	@qs.reset!
	end
	it "should reduce" do
	kvs = (0...10).collect{\|i\|[i,i*2]}
	@qs.run(["reduce", [@fun], kvs]).should == [true, [10]]
	end
	end
	describe "rereduce" do
	before(:all) do
	@fun = functions["reduce-values-sum"][LANGUAGE]
	@qs.reset!
	end
	it "should rereduce" do
	vs = (0...10).collect{\|i\|i}
	@qs.run(["rereduce", [@fun], vs]).should == [true, [45]]
	end
	end

	describe "design docs" do
	before(:all) do
	@ddoc = {
	"_id" => "foo"
	}
	@qs.reset!
	end
	it "should learn design docs" do
	@qs.teach_ddoc(@ddoc).should == true
	end
	end

	# it "should validate"
	describe "validation" do
	before(:all) do
	@fun = functions["validate-forbidden"][LANGUAGE]
	@ddoc = make_ddoc(["validate_doc_update"], @fun)
	@qs.teach_ddoc(@ddoc)
	end
	it "should allow good updates" do
	@qs.ddoc_run(@ddoc,
	["validate_doc_update"],
	[{"good" => true}, {}, {}]).should == 1
	end
	it "should reject invalid updates" do
	@qs.ddoc_run(@ddoc,
	["validate_doc_update"],
	[{"bad" => true}, {}, {}]).should == {"forbidden"=>"bad doc"}
	end
	end

	describe "show" do
	before(:all) do
	@fun = functions["show-simple"][LANGUAGE]
	@ddoc = make_ddoc(["shows","simple"], @fun)
	@qs.teach_ddoc(@ddoc)
	end
	it "should show" do
	@qs.ddoc_run(@ddoc,
	["shows","simple"],
	[{:title => "Best ever", :body => "Doc body"}, {}]).should ==
	["resp", {"body" => "Best ever - Doc body"}]
	end
	end

	describe "show with headers" do
	before(:all) do
	# TODO we can make real ddocs up there.
	@fun = functions["show-headers"][LANGUAGE]
	@ddoc = make_ddoc(["shows","headers"], @fun)
	@qs.teach_ddoc(@ddoc)
	end
	it "should show headers" do
	@qs.ddoc_run(
	@ddoc,
	["shows","headers"],
	[{:title => "Best ever", :body => "Doc body"}, {}]
	).
	should == ["resp", {"code"=>200,"headers" => {"X-Plankton"=>"Rusty"}, "body" => "Best ever - Doc body"}]
	end
	end

	describe "recoverable error" do
	before(:all) do
	@fun = functions["error"][LANGUAGE]
	@ddoc = make_ddoc(["shows","error"], @fun)
	@qs.teach_ddoc(@ddoc)
	end
	it "should not exit" do
	@qs.ddoc_run(@ddoc, ["shows","error"],
	[{"foo"=>"bar"}, {"q" => "ok"}]).
	should == ["error", "error_key", "testing"]
	# still running
	@qs.run(["reset"]).should == true
	end
	end

	describe "changes filter" do
	before(:all) do
	@fun = functions["filter-basic"][LANGUAGE]
	@ddoc = make_ddoc(["filters","basic"], @fun)
	@qs.teach_ddoc(@ddoc)
	end
	it "should only return true for good docs" do
	@qs.ddoc_run(@ddoc,
	["filters","basic"],
	[[{"key"=>"bam", "good" => true}, {"foo" => "bar"}, {"good" => true}], {"req" => "foo"}]
	).
	should == [true, [true, false, true]]
	end
	end

	describe "update" do
	before(:all) do
	# in another patch we can remove this duplication
	# by setting up the design doc for each language ahead of time.
	@fun = functions["update-basic"][LANGUAGE]
	@ddoc = make_ddoc(["updates","basic"], @fun)
	@qs.teach_ddoc(@ddoc)
	end
	it "should return a doc and a resp body" do
	up, doc, resp = @qs.ddoc_run(@ddoc,
	["updates","basic"],
	[{"foo" => "gnarly"}, {"method" => "POST"}]
	)
	up.should == "up"
	doc.should == {"foo" => "gnarly", "world" => "hello"}
	resp["body"].should == "hello doc"
	end
	end

	# end
	# LIST TESTS
	# __END__

	describe "ddoc list" do
	before(:all) do
	@ddoc = {
	"_id" => "foo",
	"lists" => {
	"simple" => functions["list-simple"][LANGUAGE],
	"headers" => functions["show-sends"][LANGUAGE],
	"rows" => functions["show-while-get-rows"][LANGUAGE],
	"buffer-chunks" => functions["show-while-get-rows-multi-send"][LANGUAGE],
	"chunky" => functions["list-chunky"][LANGUAGE]
	}
	}
	@qs.teach_ddoc(@ddoc)
	end

	describe "example list" do
	it "should run normal" do
	@qs.ddoc_run(@ddoc,
	["lists","simple"],
	[{"foo"=>"bar"}, {"q" => "ok"}]
	).should == ["start", ["first chunk", "ok"], {"headers"=>{}}]
	@qs.run(["list_row", {"key"=>"baz"}]).should == ["chunks", ["baz"]]
	@qs.run(["list_row", {"key"=>"bam"}]).should == ["chunks", ["bam"]]
	@qs.run(["list_row", {"key"=>"foom"}]).should == ["chunks", ["foom"]]
	@qs.run(["list_row", {"key"=>"fooz"}]).should == ["chunks", ["fooz"]]
	@qs.run(["list_row", {"key"=>"foox"}]).should == ["chunks", ["foox"]]
	@qs.run(["list_end"]).should == ["end" , ["early"]]
	end
	end

	describe "headers" do
	it "should do headers proper" do
	@qs.ddoc_run(@ddoc, ["lists","headers"],
	[{"total_rows"=>1000}, {"q" => "ok"}]
	).should == ["start", ["first chunk", 'second "chunk"'],
	{"headers"=>{"Content-Type"=>"text/plain"}}]
	@qs.rrun(["list_end"])
	@qs.jsgets.should == ["end", ["tail"]]
	end
	end

	describe "with rows" do
	it "should list em" do
	@qs.ddoc_run(@ddoc, ["lists","rows"],
	[{"foo"=>"bar"}, {"q" => "ok"}]).
	should == ["start", ["first chunk", "ok"], {"headers"=>{}}]
	@qs.rrun(["list_row", {"key"=>"baz"}])
	@qs.get_chunks.should == ["baz"]
	@qs.rrun(["list_row", {"key"=>"bam"}])
	@qs.get_chunks.should == ["bam"]
	@qs.rrun(["list_end"])
	@qs.jsgets.should == ["end", ["tail"]]
	end
	it "should work with zero rows" do
	@qs.ddoc_run(@ddoc, ["lists","rows"],
	[{"foo"=>"bar"}, {"q" => "ok"}]).
	should == ["start", ["first chunk", "ok"], {"headers"=>{}}]
	@qs.rrun(["list_end"])
	@qs.jsgets.should == ["end", ["tail"]]
	end
	end

	describe "should buffer multiple chunks sent for a single row." do
	it "should should buffer em" do
	@qs.ddoc_run(@ddoc, ["lists","buffer-chunks"],
	[{"foo"=>"bar"}, {"q" => "ok"}]).
	should == ["start", ["bacon"], {"headers"=>{}}]
	@qs.rrun(["list_row", {"key"=>"baz"}])
	@qs.get_chunks.should == ["baz", "eggs"]
	@qs.rrun(["list_row", {"key"=>"bam"}])
	@qs.get_chunks.should == ["bam", "eggs"]
	@qs.rrun(["list_end"])
	@qs.jsgets.should == ["end", ["tail"]]
	end
	end
	it "should end after 2" do
	@qs.ddoc_run(@ddoc, ["lists","chunky"],
	[{"foo"=>"bar"}, {"q" => "ok"}]).
	should == ["start", ["first chunk", "ok"], {"headers"=>{}}]

	@qs.run(["list_row", {"key"=>"baz"}]).
	should == ["chunks", ["baz"]]

	@qs.run(["list_row", {"key"=>"bam"}]).
	should == ["chunks", ["bam"]]

	@qs.run(["list_row", {"key"=>"foom"}]).
	should == ["end", ["foom", "early tail"]]
	# here's where js has to discard quit properly
	@qs.run(["reset"]).
	should == true
	end
	end

	describe "ddoc rewrites" do
	describe "simple rewrite" do
	before(:all) do
	@ddoc = {
	"_id" => "foo",
	"rewrites" => functions["rewrite-basic"][LANGUAGE]
	}
	@qs.teach_ddoc(@ddoc)
	end
	it "should run normal" do
	ok, resp = @qs.ddoc_run(@ddoc,
	["rewrites"],
	[{"path" => "foo/bar"}, {"method" => "POST"}]
	)
	ok.should == "ok"
	resp["path"].should == "new/location"
	end
	end

	describe "no rule" do
	before(:all) do
	@ddoc = {
	"_id" => "foo",
	"rewrites" => functions["rewrite-no-rule"][LANGUAGE]
	}
	@qs.teach_ddoc(@ddoc)
	end
	it "should run normal" do
	resp = @qs.ddoc_run(@ddoc,
	["rewrites"],
	[{"path" => "foo/bar"}, {"method" => "POST"}]
	)
	resp.should == ['no_dispatch_rule']
	end
	end
	end
	end



	def should_have_exited qs
	begin
	qs.run(["reset"])
	"raise before this (except Erlang)".should == true
	rescue RuntimeError => e
	e.message.should == "no response"
	rescue Errno::EPIPE
	true.should == true
	end
	end

	describe "query server that exits" do
	before(:each) do
	@qs = QueryServerRunner.run
	@ddoc = {
	"_id" => "foo",
	"lists" => {
	"capped" => functions["list-capped"][LANGUAGE],
	"raw" => functions["list-raw"][LANGUAGE]
	},
	"shows" => {
	"fatal" => functions["fatal"][LANGUAGE]
	}
	}
	@qs.teach_ddoc(@ddoc)
	end
	after(:each) do
	@qs.close
	end

	describe "only goes to 2 list" do
	it "should exit if erlang sends too many rows" do
	@qs.ddoc_run(@ddoc, ["lists","capped"],
	[{"foo"=>"bar"}, {"q" => "ok"}]).
	should == ["start", ["bacon"], {"headers"=>{}}]
	@qs.run(["list_row", {"key"=>"baz"}]).should == ["chunks", ["baz"]]
	@qs.run(["list_row", {"key"=>"foom"}]).should == ["chunks", ["foom"]]
	@qs.run(["list_row", {"key"=>"fooz"}]).should == ["end", ["fooz", "early"]]
	e = @qs.run(["list_row", {"key"=>"foox"}])
	e[0].should == "error"
	e[1].should == "unknown_command"
	should_have_exited @qs
	end
	end

	describe "raw list" do
	it "should exit if it gets a non-row in the middle" do
	@qs.ddoc_run(@ddoc, ["lists","raw"],
	[{"foo"=>"bar"}, {"q" => "ok"}]).
	should == ["start", ["first chunk", "ok"], {"headers"=>{}}]
	e = @qs.run(["reset"])
	e[0].should == "error"
	e[1].should == "list_error"
	should_have_exited @qs
	end
	end

	describe "fatal error" do
	it "should exit" do
	@qs.ddoc_run(@ddoc, ["shows","fatal"],
	[{"foo"=>"bar"}, {"q" => "ok"}]).
	should == ["error", "error_key", "testing"]
	should_have_exited @qs
	end
	end
	end

	describe "thank you for using the tests" do
	it "for more info run with QS_TRACE=true or see query_server_spec.rb file header" do
	end
	end