Adds support for metadata to the surface APIs

- received metadata is visible on the ActiveCall object
- metadata to send is keyword args on ActiveCall objects

Also
- fixes a typo that meant that the wrong error error code might be returned
- fixes bad references in some tests that are only visible when run via rspec
	Change on 2014/12/10 by temiola <temiola@google.com>
-------------
Created by MOE: http://code.google.com/p/moe-java
MOE_MIGRATED_REVID=81811008

1 files changed, 112 insertions, 45 deletions

diff --git a/src/ruby/spec/generic/active_call_spec.rb b/src/ruby/spec/generic/active_call_spec.rb
index ceeef2a1d8..a8ee3c0da8 100644
--- a/src/ruby/spec/generic/active_call_spec.rb
+++ b/src/ruby/spec/generic/active_call_spec.rb
@@ -31,14 +31,17 @@ require 'grpc'
 require 'grpc/generic/active_call'
 require_relative '../port_picker'
 
-ActiveCall = GRPC::ActiveCall
+include GRPC::Core::StatusCodes
 
 describe GRPC::ActiveCall do
+  ActiveCall = GRPC::ActiveCall
+  Call = GRPC::Core::Call
+  CompletionType = GRPC::Core::CompletionType
 
   before(:each) do
     @pass_through = Proc.new { |x| x }
     @server_tag = Object.new
-    @server_finished_tag = Object.new
+    @server_done_tag, meta_tag = Object.new
     @tag = Object.new
 
     @client_queue = GRPC::Core::CompletionQueue.new
@@ -58,11 +61,12 @@ describe GRPC::ActiveCall do
   describe 'restricted view methods' do
     before(:each) do
       call = make_test_call
-      finished_tag = ActiveCall.client_start_invoke(call, @client_queue,
-                                                    deadline)
+      done_tag, meta_tag = ActiveCall.client_start_invoke(call, @client_queue,
+                                                          deadline)
       @client_call = ActiveCall.new(call, @client_queue, @pass_through,
                                     @pass_through, deadline,
-                                    finished_tag: finished_tag)
+                                    finished_tag: done_tag,
+                                    read_metadata_tag: meta_tag)
     end
 
     describe '#multi_req_view' do
@@ -89,11 +93,12 @@ describe GRPC::ActiveCall do
   describe '#remote_send' do
     it 'allows a client to send a payload to the server' do
       call = make_test_call
-      finished_tag = ActiveCall.client_start_invoke(call, @client_queue,
-                                                    deadline)
+      done_tag, meta_tag = ActiveCall.client_start_invoke(call, @client_queue,
+                                                          deadline)
       @client_call = ActiveCall.new(call, @client_queue, @pass_through,
                                     @pass_through, deadline,
-                                    finished_tag: finished_tag)
+                                    finished_tag: done_tag,
+                                    read_metadata_tag: meta_tag)
       msg = 'message is a string'
       @client_call.remote_send(msg)
 
@@ -113,12 +118,13 @@ describe GRPC::ActiveCall do
 
     it 'marshals the payload using the marshal func' do
       call = make_test_call
-      finished_tag = ActiveCall.client_start_invoke(call, @client_queue,
-                                                    deadline)
+      done_tag, meta_tag = ActiveCall.client_start_invoke(call, @client_queue,
+                                                          deadline)
       marshal = Proc.new { |x| 'marshalled:' + x }
       client_call = ActiveCall.new(call, @client_queue, marshal,
                                    @pass_through, deadline,
-                                   finished_tag: finished_tag)
+                                   finished_tag: done_tag,
+                                   read_metadata_tag: meta_tag)
       msg = 'message is a string'
       client_call.remote_send(msg)
 
@@ -133,14 +139,31 @@ describe GRPC::ActiveCall do
 
   end
 
+  describe '#client_start_invoke' do
+
+    it 'sends keywords as metadata to the server when the are present' do
+      call, pass_through = make_test_call, Proc.new { |x| x }
+      done_tag, meta_tag = ActiveCall.client_start_invoke(call, @client_queue,
+                                                          deadline, k1: 'v1',
+                                                          k2: 'v2')
+      @server.request_call(@server_tag)
+      ev = @server_queue.next(deadline)
+      expect(ev).to_not be_nil
+      expect(ev.result.metadata['k1']).to eq('v1')
+      expect(ev.result.metadata['k2']).to eq('v2')
+    end
+
+  end
+
   describe '#remote_read' do
     it 'reads the response sent by a server' do
       call, pass_through = make_test_call, Proc.new { |x| x }
-      finished_tag = ActiveCall.client_start_invoke(call, @client_queue,
-                                                    deadline)
+      done_tag, meta_tag = ActiveCall.client_start_invoke(call, @client_queue,
+                                                          deadline)
       client_call = ActiveCall.new(call, @client_queue, @pass_through,
                                    @pass_through, deadline,
-                                   finished_tag: finished_tag)
+                                   finished_tag: done_tag,
+                                   read_metadata_tag: meta_tag)
       msg = 'message is a string'
       client_call.remote_send(msg)
       server_call = expect_server_to_receive(msg)
@@ -148,19 +171,56 @@ describe GRPC::ActiveCall do
       expect(client_call.remote_read).to eq('server_response')
     end
 
+    it 'saves metadata { status=200 } when the server adds no metadata' do
+      call, pass_through = make_test_call, Proc.new { |x| x }
+      done_tag, meta_tag = ActiveCall.client_start_invoke(call, @client_queue,
+                                                          deadline)
+      client_call = ActiveCall.new(call, @client_queue, @pass_through,
+                                   @pass_through, deadline,
+                                   finished_tag: done_tag,
+                                   read_metadata_tag: meta_tag)
+      msg = 'message is a string'
+      client_call.remote_send(msg)
+      server_call = expect_server_to_receive(msg)
+      server_call.remote_send('ignore me')
+      expect(client_call.metadata).to be_nil
+      client_call.remote_read
+      expect(client_call.metadata).to eq({':status' => '200'})
+    end
+
+    it 'saves metadata add by the server' do
+      call, pass_through = make_test_call, Proc.new { |x| x }
+      done_tag, meta_tag = ActiveCall.client_start_invoke(call, @client_queue,
+                                                          deadline)
+      client_call = ActiveCall.new(call, @client_queue, @pass_through,
+                                   @pass_through, deadline,
+                                   finished_tag: done_tag,
+                                   read_metadata_tag: meta_tag)
+      msg = 'message is a string'
+      client_call.remote_send(msg)
+      server_call = expect_server_to_receive(msg, k1: 'v1', k2: 'v2')
+      server_call.remote_send('ignore me')
+      expect(client_call.metadata).to be_nil
+      client_call.remote_read
+      expect(client_call.metadata).to eq({':status' => '200', 'k1' => 'v1',
+                                           'k2' => 'v2'})
+    end
+
+
     it 'get a nil msg before a status when an OK status is sent' do
       call, pass_through = make_test_call, Proc.new { |x| x }
-      finished_tag = ActiveCall.client_start_invoke(call, @client_queue,
-                                                    deadline)
+      done_tag, meta_tag = ActiveCall.client_start_invoke(call, @client_queue,
+                                                          deadline)
       client_call = ActiveCall.new(call, @client_queue, @pass_through,
                                    @pass_through, deadline,
-                                   finished_tag: finished_tag)
+                                   finished_tag: done_tag,
+                                   read_metadata_tag: meta_tag)
       msg = 'message is a string'
       client_call.remote_send(msg)
       client_call.writes_done(false)
       server_call = expect_server_to_receive(msg)
       server_call.remote_send('server_response')
-      server_call.send_status(StatusCodes::OK, 'OK')
+      server_call.send_status(OK, 'OK')
       expect(client_call.remote_read).to eq('server_response')
       res = client_call.remote_read
       expect(res).to be_nil
@@ -169,12 +229,13 @@ describe GRPC::ActiveCall do
 
     it 'unmarshals the response using the unmarshal func' do
       call = make_test_call
-      finished_tag = ActiveCall.client_start_invoke(call, @client_queue,
-                                                    deadline)
+      done_tag, meta_tag = ActiveCall.client_start_invoke(call, @client_queue,
+                                                          deadline)
       unmarshal = Proc.new { |x| 'unmarshalled:' + x }
       client_call = ActiveCall.new(call, @client_queue, @pass_through,
                                    unmarshal, deadline,
-                                   finished_tag: finished_tag)
+                                   finished_tag: done_tag,
+                                   read_metadata_tag: meta_tag)
 
       # confirm the client receives the unmarshalled message
       msg = 'message is a string'
@@ -196,11 +257,12 @@ describe GRPC::ActiveCall do
 
     it 'the returns an enumerator that can read n responses' do
       call = make_test_call
-      finished_tag = ActiveCall.client_start_invoke(call, @client_queue,
-                                                    deadline)
+      done_tag, meta_tag = ActiveCall.client_start_invoke(call, @client_queue,
+                                                          deadline)
       client_call = ActiveCall.new(call, @client_queue, @pass_through,
                                    @pass_through, deadline,
-                                   finished_tag: finished_tag)
+                                   finished_tag: done_tag,
+                                   read_metadata_tag: meta_tag)
       msg = 'message is 4a string'
       reply = 'server_response'
       client_call.remote_send(msg)
@@ -215,11 +277,12 @@ describe GRPC::ActiveCall do
 
     it 'the returns an enumerator that stops after an OK Status' do
       call = make_test_call
-      finished_tag = ActiveCall.client_start_invoke(call, @client_queue,
-                                                    deadline)
+      done_tag, meta_tag = ActiveCall.client_start_invoke(call, @client_queue,
+                                                          deadline)
       client_call = ActiveCall.new(call, @client_queue, @pass_through,
                                    @pass_through, deadline,
-                                   finished_tag: finished_tag)
+                                   read_metadata_tag: meta_tag,
+                                   finished_tag: done_tag)
       msg = 'message is a string'
       reply = 'server_response'
       client_call.remote_send(msg)
@@ -231,7 +294,7 @@ describe GRPC::ActiveCall do
         server_call.remote_send(reply)
         expect(e.next).to eq(reply)
       end
-      server_call.send_status(StatusCodes::OK, 'OK')
+      server_call.send_status(OK, 'OK')
       expect { e.next }.to raise_error(StopIteration)
     end
 
@@ -240,34 +303,36 @@ describe GRPC::ActiveCall do
   describe '#writes_done' do
     it 'finishes ok if the server sends a status response' do
       call = make_test_call
-      finished_tag = ActiveCall.client_start_invoke(call, @client_queue,
-                                                    deadline)
+      done_tag, meta_tag = ActiveCall.client_start_invoke(call, @client_queue,
+                                                          deadline)
       client_call = ActiveCall.new(call, @client_queue, @pass_through,
                                    @pass_through, deadline,
-                                   finished_tag: finished_tag)
+                                   finished_tag: done_tag,
+                                   read_metadata_tag: meta_tag)
       msg = 'message is a string'
       client_call.remote_send(msg)
       expect { client_call.writes_done(false) }.to_not raise_error
       server_call = expect_server_to_receive(msg)
       server_call.remote_send('server_response')
       expect(client_call.remote_read).to eq('server_response')
-      server_call.send_status(StatusCodes::OK, 'status code is OK')
+      server_call.send_status(OK, 'status code is OK')
       expect { server_call.finished }.to_not raise_error
       expect { client_call.finished }.to_not raise_error
     end
 
     it 'finishes ok if the server sends an early status response' do
       call = make_test_call
-      finished_tag = ActiveCall.client_start_invoke(call, @client_queue,
-                                                    deadline)
+      done_tag, meta_tag = ActiveCall.client_start_invoke(call, @client_queue,
+                                                          deadline)
       client_call = ActiveCall.new(call, @client_queue, @pass_through,
                                    @pass_through, deadline,
-                                   finished_tag: finished_tag)
+                                   read_metadata_tag: meta_tag,
+                                   finished_tag: done_tag)
       msg = 'message is a string'
       client_call.remote_send(msg)
       server_call = expect_server_to_receive(msg)
       server_call.remote_send('server_response')
-      server_call.send_status(StatusCodes::OK, 'status code is OK')
+      server_call.send_status(OK, 'status code is OK')
       expect(client_call.remote_read).to eq('server_response')
       expect { client_call.writes_done(false) }.to_not raise_error
       expect { server_call.finished }.to_not raise_error
@@ -276,16 +341,17 @@ describe GRPC::ActiveCall do
 
     it 'finishes ok if writes_done is true' do
       call = make_test_call
-      finished_tag = ActiveCall.client_start_invoke(call, @client_queue,
-                                                    deadline)
+      done_tag, meta_tag = ActiveCall.client_start_invoke(call, @client_queue,
+                                                          deadline)
       client_call = ActiveCall.new(call, @client_queue, @pass_through,
                                    @pass_through, deadline,
-                                   finished_tag: finished_tag)
+                                   read_metadata_tag: meta_tag,
+                                   finished_tag: done_tag)
       msg = 'message is a string'
       client_call.remote_send(msg)
       server_call = expect_server_to_receive(msg)
       server_call.remote_send('server_response')
-      server_call.send_status(StatusCodes::OK, 'status code is OK')
+      server_call.send_status(OK, 'status code is OK')
       expect(client_call.remote_read).to eq('server_response')
       expect { client_call.writes_done(true) }.to_not raise_error
       expect { server_call.finished }.to_not raise_error
@@ -293,19 +359,20 @@ describe GRPC::ActiveCall do
 
   end
 
-  def expect_server_to_receive(sent_text)
-    c = expect_server_to_be_invoked
+  def expect_server_to_receive(sent_text, **kw)
+    c = expect_server_to_be_invoked(**kw)
     expect(c.remote_read).to eq(sent_text)
     c
   end
 
-  def expect_server_to_be_invoked()
+  def expect_server_to_be_invoked(**kw)
     @server.request_call(@server_tag)
     ev = @server_queue.next(deadline)
-    ev.call.accept(@client_queue, @server_finished_tag)
+    ev.call.add_metadata(kw)
+    ev.call.accept(@client_queue, @server_done_tag)
     ActiveCall.new(ev.call, @client_queue, @pass_through,
                    @pass_through, deadline,
-                   finished_tag: @server_finished_tag)
+                   finished_tag: @server_done_tag)
   end
 
   def make_test_call