couchdb-ruby-server 1.0.0

data/lib/couchdb-ruby-server/version.rb

@@ -0,0 +1,5 @@
+# coding: utf-8
+
+module CouchdbRubyServer
+  VERSION = '1.0.0'
+end

data/lib/couchdb-ruby-server.rb

@@ -0,0 +1,8 @@
+# coding: utf-8
+
+require 'oj'
+::Oj.default_options = {:mode        => :compat,
+                        :class_cache => true }
+
+require 'couchdb-ruby-server/version'
+require 'couchdb-ruby-server/server'

data/spec/couchdb-ruby-server_spec.rb

@@ -0,0 +1,952 @@
+# 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)
+#
+require 'json'
+
+COUCH_ROOT = "#{File.dirname(__FILE__)}/../.." unless defined?(COUCH_ROOT)
+LANGUAGE = ENV["QS_LANG"] || "ruby"
+
+puts "Running query server specs for #{LANGUAGE} query server"
+
+require 'spec_helper'
+
+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",
+    "ruby" => "bin/couchdb-ruby-server"
+  }
+
+  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
+    "ruby" => <<-RUBY
+      lambda {|doc| emit("foo",doc['a']); emit("bar",doc['a'])}
+    RUBY
+  },
+  "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
+    "ruby" => <<-RUBY
+      lambda {|doc| emit("baz", doc['a'])}
+    RUBY
+  },
+  "reduce-values-length" => {
+    "js" => %{function(keys, values, rereduce) { return values.length; }},
+    "erlang" => %{fun(Keys, Values, ReReduce) -> length(Values) end.},
+    "ruby" => %{lambda {|keys, values, rereduce| values.size }}
+  },
+  "reduce-values-sum" => {
+    "js" => %{function(keys, values, rereduce) { return sum(values); }},
+    "erlang" => %{fun(Keys, Values, ReReduce) -> lists:sum(Values) end.},
+    "ruby" => %{lambda {|keys, values, rereduce| values.reduce(0) {|sum, v| sum += v}}}
+  },
+  "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
+    "ruby" => <<-RUBY
+      lambda do |newDoc, oldDoc, userCtx|
+          raise Error.new(:forbidden), 'bad doc' if newDoc['bad']
+          "foo bar"
+      end
+      RUBY
+  },
+  "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
+    "ruby" => <<-RUBY
+        lambda { |doc, req|
+            log("ok");
+            [doc['title'], doc['body']].join(' - ');
+        }
+    RUBY
+  },
+  "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
+    "ruby" => <<-RUBY
+        lambda { |doc, req|
+          resp = {:code=>200, :headers=>{"X-Plankton"=>"Rusty"}};
+          resp[:body] = [doc['title'], doc['body']].join(' - ');
+          resp
+        }
+    RUBY
+  },
+  "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
+    "ruby" => <<-RUBY
+        lambda { |head, req|
+          start({:headers => {"Content-Type" => "text/plain"}});
+          send("first chunk");
+          send('second "chunk"');
+          "tail"
+        }
+    RUBY
+  },
+  "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
+    "ruby" => <<-RUBY
+        lambda { |head, req|
+          send("first chunk");
+          send(req['q']);
+          while(row = get_row)
+            send(row['key']);
+          end
+          "tail";
+        }
+    RUBY
+  },
+  "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
+    "ruby" => <<-RUBY
+        lambda do |head, req|
+          send("bacon");
+          while(row = get_row)
+            send(row['key']);
+            send("eggs");
+          end
+          "tail";
+        end
+    RUBY
+  },
+  "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
+    "ruby" => <<-RUBY
+        lambda do |head, req|
+          send("first chunk");
+          send(req['q']);
+          while(row = get_row)
+            send(row['key']);
+          end
+          "early";
+        end
+    RUBY
+  },
+  "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
+    "ruby" => <<-RUBY
+        lambda do |head, req|
+          send("first chunk");
+          send(req['q']);
+          i=0
+          while(row = get_row)
+            send(row['key']);
+            i += 1;
+            return 'early tail' if i > 2
+          end
+        end
+    RUBY
+  },
+  "list-old-style" => {
+    "js" => <<-JS,
+        function(head, req, foo, bar) {
+          return "stuff";
+        }
+    JS
+    "erlang" => <<-ERLANG,
+        fun(Head, Req, Foo, Bar) ->
+            <<"stuff">>
+        end.
+    ERLANG
+    "ruby" => <<-RUBY
+        lambda do |head, req, foo, bar|
+          send "stuff"
+        end
+    RUBY
+  },
+  "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
+    "ruby" => <<-RUBY
+        lambda do |head, req|
+          send("bacon")
+          i = 0;
+          while(row = get_row)
+            send(row['key']);
+            i += 1;
+            return 'early' if i > 2
+          end
+        end
+    RUBY
+  },
+  "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
+    "ruby" => <<-RUBY
+        lambda do |head, req|
+          # log(this.toSource());
+          # log(typeof send);
+          send("first chunk");
+          send(req['q']);
+          while(row = get_row)
+            send(row['key']);
+          end
+          "tail";
+        end
+    RUBY
+  },
+  "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
+    "ruby" => <<-RUBY
+      lambda { |doc, req|
+        doc['good']
+      }
+    RUBY
+  },
+  "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
+    "ruby" => <<-RUBY
+      lambda { |doc, req|
+        doc['world'] = "hello";
+        resp = [doc, "hello doc"];
+        return resp;
+      }
+    RUBY
+  },
+  "error" => {
+    "js" => <<-JS,
+    function() {
+      throw(["error","error_key","testing"]);
+    }
+    JS
+    "erlang" => <<-ERLANG,
+    fun(A, B) ->
+      throw([<<"error">>,<<"error_key">>,<<"testing">>])
+    end.
+    ERLANG
+    "ruby" => <<-RUBY
+      lambda { |*args|
+        raise Error.new(:error_key), "testing"
+      }
+    RUBY
+  },
+  "fatal" => {
+    "js" => <<-JS,
+    function() {
+      throw(["fatal","error_key","testing"]);
+    }
+    JS
+    "erlang" => <<-ERLANG,
+    fun(A, B) ->
+      throw([<<"fatal">>,<<"error_key">>,<<"testing">>])
+    end.
+    ERLANG
+    "ruby" => <<-RUBY
+      lambda { |*args|
+        raise Fatal.new(:error_key), "testing"
+      }
+    RUBY
+  }
+}
+
+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` unless LANGUAGE == 'ruby'
+    @qs = QueryServerRunner.run
+  end
+  after(:all) do
+    @qs.close
+  end
+  it "should reset" do
+    @qs.run(["reset"]).must_equal 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"]).must_equal true
+    @qs.ddoc_run(@ddoc,
+      ["shows","simple"],
+      [{:title => "Best ever", :body => "Doc body"}, {}]).
+        must_equal ["resp", {"body" => "Best ever - Doc body"}]
+  end
+
+  it "should run map funs" do
+    @qs.reset!
+    @qs.run(["add_fun", functions["emit-twice"][LANGUAGE]]).must_equal true
+    @qs.run(["add_fun", functions["emit-once"][LANGUAGE]]).must_equal true
+    rows = @qs.run(["map_doc", {:a => "b"}])
+    rows[0][0].must_equal ["foo", "b"]
+    rows[0][1].must_equal ["bar", "b"]
+    rows[1][0].must_equal ["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]).must_equal [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]).must_equal [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).must_equal 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}, {}, {}]).must_equal 1
+    end
+    it "should reject invalid updates" do
+      @qs.ddoc_run(@ddoc,
+        ["validate_doc_update"],
+        [{"bad" => true}, {}, {}]).must_equal({"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"}, {}]).
+        must_equal ["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"}, {}]
+      ).
+      must_equal ["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"}]).
+        must_equal ["error", "error_key", "testing"]
+      # still running
+      @qs.run(["reset"]).must_equal 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"}]
+      ).
+      must_equal [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.must_equal "up"
+      doc.must_equal({"foo" => "gnarly", "world" => "hello"})
+      resp["body"].must_equal "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"}]
+          ).must_equal ["start", ["first chunk", "ok"], {"headers"=>{}}]
+          @qs.run(["list_row", {"key"=>"baz"}]).must_equal  ["chunks", ["baz"]]
+          @qs.run(["list_row", {"key"=>"bam"}]).must_equal  ["chunks", ["bam"]]
+          @qs.run(["list_row", {"key"=>"foom"}]).must_equal ["chunks", ["foom"]]
+          @qs.run(["list_row", {"key"=>"fooz"}]).must_equal ["chunks", ["fooz"]]
+          @qs.run(["list_row", {"key"=>"foox"}]).must_equal ["chunks", ["foox"]]
+          @qs.run(["list_end"]).must_equal ["end" , ["early"]]
+        end
+      end
+
+      describe "headers" do
+        it "should do headers proper" do
+          @qs.ddoc_run(@ddoc, ["lists","headers"],
+            [{"total_rows"=>1000}, {"q" => "ok"}]
+          ).must_equal ["start", ["first chunk", 'second "chunk"'],
+            {"headers"=>{"Content-Type"=>"text/plain"}}]
+          @qs.rrun(["list_end"])
+          @qs.jsgets.must_equal ["end", ["tail"]]
+        end
+      end
+
+      describe "with rows" do
+        it "should list em" do
+          @qs.ddoc_run(@ddoc, ["lists","rows"],
+            [{"foo"=>"bar"}, {"q" => "ok"}]).
+            must_equal ["start", ["first chunk", "ok"], {"headers"=>{}}]
+          @qs.rrun(["list_row", {"key"=>"baz"}])
+          @qs.get_chunks.must_equal ["baz"]
+          @qs.rrun(["list_row", {"key"=>"bam"}])
+          @qs.get_chunks.must_equal ["bam"]
+          @qs.rrun(["list_end"])
+          @qs.jsgets.must_equal ["end", ["tail"]]
+        end
+        it "should work with zero rows" do
+          @qs.ddoc_run(@ddoc, ["lists","rows"],
+            [{"foo"=>"bar"}, {"q" => "ok"}]).
+            must_equal ["start", ["first chunk", "ok"], {"headers"=>{}}]
+          @qs.rrun(["list_end"])
+          @qs.jsgets.must_equal ["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"}]).
+            must_equal ["start", ["bacon"], {"headers"=>{}}]
+          @qs.rrun(["list_row", {"key"=>"baz"}])
+          @qs.get_chunks.must_equal ["baz", "eggs"]
+          @qs.rrun(["list_row", {"key"=>"bam"}])
+          @qs.get_chunks.must_equal ["bam", "eggs"]
+          @qs.rrun(["list_end"])
+          @qs.jsgets.must_equal ["end", ["tail"]]
+        end
+      end
+      it "should end after 2" do
+        @qs.ddoc_run(@ddoc, ["lists","chunky"],
+          [{"foo"=>"bar"}, {"q" => "ok"}]).
+          must_equal ["start", ["first chunk", "ok"], {"headers"=>{}}]
+
+        @qs.run(["list_row", {"key"=>"baz"}]).
+          must_equal ["chunks", ["baz"]]
+
+        @qs.run(["list_row", {"key"=>"bam"}]).
+          must_equal ["chunks", ["bam"]]
+
+        @qs.run(["list_row", {"key"=>"foom"}]).
+          must_equal ["end", ["foom", "early tail"]]
+        # here's where js has to discard quit properly
+        @qs.run(["reset"]).
+          must_equal true
+      end
+    end
+  end
+
+
+
+def should_have_exited qs
+  begin
+    qs.run(["reset"])
+    "raise before this (except Erlang)".must_equal true
+  rescue RuntimeError => e
+    e.message.must_equal "no response"
+  rescue Errno::EPIPE
+    true.must_equal 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"}]).
+        must_equal ["start", ["bacon"], {"headers"=>{}}]
+      @qs.run(["list_row", {"key"=>"baz"}]).must_equal  ["chunks", ["baz"]]
+      @qs.run(["list_row", {"key"=>"foom"}]).must_equal ["chunks", ["foom"]]
+      @qs.run(["list_row", {"key"=>"fooz"}]).must_equal ["end", ["fooz", "early"]]
+      e = @qs.run(["list_row", {"key"=>"foox"}])
+      e[0].must_equal "error"
+      e[1].must_equal "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"}]).
+        must_equal ["start", ["first chunk", "ok"], {"headers"=>{}}]
+      e = @qs.run(["reset"])
+      e[0].must_equal "error"
+      e[1].must_equal "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"}]).
+        must_equal ["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