etcdv3 0.10.1 → 0.11.5

data/spec/etcdv3/connection_wrapper_spec.rb

@@ -3,9 +3,9 @@ require 'spec_helper'
 describe Etcdv3::ConnectionWrapper do
   let(:conn) { local_connection }
   let(:endpoints) { ['http://localhost:2379', 'http://localhost:2389'] }
+  subject { Etcdv3::ConnectionWrapper.new(10, *endpoints, nil, true) }
 
   describe '#initialize' do
-    subject { Etcdv3::ConnectionWrapper.new(10, *endpoints) }
     it { is_expected.to have_attributes(user: nil, password: nil, token: nil) }
     it 'sets hostnames in correct order' do
       expect(subject.endpoints.map(&:hostname)).to eq(['localhost:2379', 'localhost:2389'])
@@ -16,7 +16,6 @@ describe Etcdv3::ConnectionWrapper do
   end
 
   describe "#rotate_connection_endpoint" do
-    subject { Etcdv3::ConnectionWrapper.new(10, *endpoints) }
     before do
       subject.rotate_connection_endpoint
     end
@@ -29,11 +28,30 @@ describe Etcdv3::ConnectionWrapper do
   end
 
   describe "Failover Simulation" do
-    let(:modified_conn) { local_connection("http://localhost:2369, http://localhost:2379") }
+    let(:allow_reconnect) { true }
+    let(:modified_conn) {
+      local_connection(
+        "http://localhost:2369, http://localhost:2379",
+        allow_reconnect: allow_reconnect
+      )
+    }
+    subject { modified_conn.get('boom') }
+
     context 'without auth' do
       # Set primary endpoint to a non-existing etcd endpoint
-      subject { modified_conn.get('boom') }
-      it { is_expected.to be_an_instance_of(Etcdserverpb::RangeResponse) }
+      context 'with reconnect' do
+        it { is_expected.to be_an_instance_of(Etcdserverpb::RangeResponse) }
+      end
+      context 'without reconnect' do
+        let(:allow_reconnect) { false }
+        it { expect { subject }.to raise_error(GRPC::Unavailable) }
+      end
+      context 'without reconnect with single endpoint' do
+        let(:modified_conn) {
+          local_connection("http://localhost:2369",allow_reconnect: false)
+        }
+        it { expect { subject }.to raise_error(GRPC::Unavailable) }
+      end
     end
     context 'with auth' do
       before do
@@ -50,12 +68,19 @@ describe Etcdv3::ConnectionWrapper do
         modified_conn.auth_disable
         modified_conn.user_delete('root')
       end
-      subject { modified_conn.get('boom') }
-      it { is_expected.to be_an_instance_of(Etcdserverpb::RangeResponse) }
+      context 'with reconnect' do
+        it { is_expected.to be_an_instance_of(Etcdserverpb::RangeResponse) }
+      end
+      context 'without reconnect' do
+        let(:allow_reconnect) { false }
+        it { expect { subject }.to raise_error(GRPC::Unavailable) }
+      end
     end
   end
 
   describe "GRPC::Unauthenticated recovery" do
+    let(:allow_reconnect) { true }
+    let(:conn) { local_connection(allow_reconnect: allow_reconnect) }
     let(:wrapper) { conn.send(:conn) }
     let(:connection) { wrapper.connection }
     before do
@@ -71,6 +96,12 @@ describe Etcdv3::ConnectionWrapper do
       conn.user_delete('root')
     end
     subject { conn.user_get('root') }
-    it { is_expected.to be_an_instance_of(Etcdserverpb::AuthUserGetResponse) }
+    context 'with reconnect' do
+      it { is_expected.to be_an_instance_of(Etcdserverpb::AuthUserGetResponse) }
+    end
+    context 'without reconnect' do
+      let(:allow_reconnect) { false }
+      it { expect { subject }.to raise_error(GRPC::Unauthenticated) }
+    end
   end
 end

data/spec/etcdv3/lock_spec.rb

@@ -10,14 +10,28 @@ unless $instance.version < Gem::Version.new("3.2.0")
     #it_should_behave_like "a method with a GRPC timeout", described_class, :lock, :lock, 'foo'
 
     describe '#lock' do
-      let(:lease_id) { lease_stub.lease_grant(10)['ID'] }
-      subject { stub.lock('foo', lease_id) }
-      it { is_expected.to be_an_instance_of(V3lockpb::LockResponse) }
+      it 'returns a response' do
+        lease_id = lease_stub.lease_grant(10)['ID']
+
+        expect(stub.lock('example1', lease_id)).to be_an_instance_of(V3lockpb::LockResponse)
+      end
+
+      it 'passes metadata correctly' do
+        lease_id = lease_stub.lease_grant(10)['ID']
+        stub = expect_metadata_passthrough(described_class, :lock, :lock)
+        stub.lock('example2', lease_id)
+      end
     end
 
     describe '#unlock' do
-      subject { stub.unlock('foo') }
-      it { is_expected.to be_an_instance_of(V3lockpb::UnlockResponse) }
+      it 'returns a response' do
+        expect(stub.unlock('example3')).to be_an_instance_of(V3lockpb::UnlockResponse)
+      end
+
+      it 'passes metadata correctly' do
+        stub = expect_metadata_passthrough(described_class, :unlock, :unlock)
+        stub.unlock('example4')
+      end
     end
   end
 end

data/spec/etcdv3/namespace/kv_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Etcdv3::KV do
+  let(:stub) { local_namespace_stub(Etcdv3::Namespace::KV, 1, '/namespace/') }
+  let(:lease_stub) { local_stub(Etcdv3::Lease, 1) }
+
+  it_should_behave_like "a method with a GRPC timeout", described_class, :get, :range, "key"
+  it_should_behave_like "a method with a GRPC timeout", described_class, :del, :delete_range, "key"
+  it_should_behave_like "a method with a GRPC timeout", described_class, :put, :put, "key", "val"
+
+  it "should timeout transactions" do
+    stub = local_namespace_stub(Etcdv3::Namespace::KV, 0, '/namespace/')
+    expect { stub.transaction(Proc.new { nil }) }.to raise_error(GRPC::DeadlineExceeded)
+  end
+
+  describe '#put' do
+    context 'without lease' do
+      subject { stub.put('test', 'test') }
+      it { is_expected.to be_an_instance_of(Etcdserverpb::PutResponse) }
+    end
+
+    context 'with lease' do
+      let(:lease_id) { lease_stub.lease_grant(1)['ID'] }
+      subject { stub.put('lease', 'test', lease: lease_id) }
+      it { is_expected.to be_an_instance_of(Etcdserverpb::PutResponse) }
+    end
+  end
+
+  describe '#get' do
+    subject { stub.get('test') }
+    it { is_expected.to be_an_instance_of(Etcdserverpb::RangeResponse) }
+  end
+
+  describe '#del' do
+    context 'del without range' do
+      subject { stub.del('test') }
+      it { is_expected.to be_an_instance_of(Etcdserverpb::DeleteRangeResponse) }
+    end
+    context 'del with range' do
+      subject { stub.del('test', range_end: 'testtt') }
+      it { is_expected.to be_an_instance_of(Etcdserverpb::DeleteRangeResponse) }
+    end
+  end
+
+  describe '#transaction' do
+    context 'put' do
+      let!(:block) do
+        Proc.new do |txn|
+          txn.compare = [ txn.value('txn', :equal, 'value') ]
+          txn.success = [ txn.put('txn-test', 'success') ]
+          txn.failure = [ txn.put('txn-test', 'failed') ]
+        end
+      end
+      subject { stub.transaction(block) }
+      it { is_expected.to be_an_instance_of(Etcdserverpb::TxnResponse) }
+    end
+
+    context 'del' do
+      let!(:block) do
+        Proc.new do |txn|
+          txn.compare = [ txn.value('txn', :equal, 'value') ]
+          txn.success = [ txn.del('txn-one') ]
+          txn.failure = [ txn.del('txn-two') ]
+        end
+      end
+      subject { stub.transaction(block) }
+      it { is_expected.to be_an_instance_of(Etcdserverpb::TxnResponse) }
+    end
+  end
+
+  context 'get' do
+    let!(:block) do
+      Proc.new do |txn|
+        txn.compare = [ txn.value('txn', :equal, 'value') ]
+        txn.success = [ txn.get('txn-success') ]
+        txn.failure = [ txn.get('txn-failure') ]
+      end
+    end
+    subject { stub.transaction(block) }
+    it { is_expected.to be_an_instance_of(Etcdserverpb::TxnResponse) }
+  end
+end

data/spec/etcdv3/namespace/lock_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+# Locking is not implemented in etcd v3.1.X
+unless $instance.version < Gem::Version.new("3.2.0")
+  describe Etcdv3::Namespace::Lock do
+    let(:stub) { local_namespace_stub(Etcdv3::Namespace::Lock, 1, '/namespace/') }
+    let(:lease_stub) { local_stub(Etcdv3::Lease, 1) }
+
+    # NOTE: this was running duplicate tests against Etcdv3::Lock before, but it
+    # doesn't work with Etcdv3::Namespace::Lock
+    #
+    # it_should_behave_like "a method with a GRPC timeout", described_class, :unlock, :unlock, 'foo'
+
+    # it_should_behave_like "a method with a GRPC timeout", described_class, :lock, :lock, 'foo'
+
+    describe '#lock' do
+      it 'returns a response' do
+        lease_id = lease_stub.lease_grant(10)['ID']
+        expect(stub.lock('example1', lease_id)).to(
+          be_an_instance_of(V3lockpb::LockResponse)
+        )
+      end
+
+      it 'passes metadata correctly' do
+        lease_id = lease_stub.lease_grant(10)['ID']
+        stub = expect_metadata_passthrough_namespace(described_class, :lock, :lock, '/namespace/')
+        stub.lock('example2', lease_id)
+      end
+    end
+
+    describe '#unlock' do
+      it 'returns a response' do
+        expect(stub.unlock('example3')).to be_an_instance_of(V3lockpb::UnlockResponse)
+      end
+
+      it 'passes metadata correctly' do
+        stub = expect_metadata_passthrough_namespace(described_class, :unlock, :unlock, '/namespace/')
+        stub.unlock('example4')
+      end
+    end
+  end
+end

data/spec/etcdv3/namespace/watch_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'securerandom'
+
+
+describe Etcdv3::Namespace::Watch do
+  let(:stub) { local_namespace_stub(Etcdv3::Namespace::Watch, 5, '/namespace/') }
+  let(:kv_stub_no_ns) { local_stub(Etcdv3::KV, 1) }
+  let(:kv_stub) { local_namespace_stub(Etcdv3::Namespace::KV, 1, '/namespace/') }
+
+  context 'watch' do
+    it 'should return an event' do 
+      resp = nil
+      thr = Thread.new do |thr|
+        resp = stub.watch("foo", nil, 1, nil)
+      end
+      sleep 2
+      kv_stub.put("foo", "works")
+      thr.join
+      expect(resp).to be_an_instance_of(Google::Protobuf::RepeatedField)
+      expect(resp.last.kv.key).to eq('foo')  
+    end
+
+    it 'should return event when non-namespace client writes to key' do 
+      resp = nil
+      thr = Thread.new do |thr|
+        resp = stub.watch("foobar", nil, 1, nil)
+      end
+      sleep 2
+      kv_stub_no_ns.put("/namespace/foobar", "works")
+      thr.join
+      expect(resp).to be_an_instance_of(Google::Protobuf::RepeatedField)
+      expect(resp.last.kv.key).to eq('foobar')  
+    end
+  end
+end
+

data/spec/etcdv3/watch_spec.rb

@@ -4,14 +4,21 @@ require 'securerandom'
 # Locking is not implemented in etcd v3.1.X
 unless $instance.version < Gem::Version.new("3.2.0")
   describe Etcdv3::Watch do
-    let(:stub) { local_stub(Etcdv3::Watch, 1) }
+    let(:stub) { local_stub(Etcdv3::Watch, 5) }
     let(:kv_stub) { local_stub(Etcdv3::KV, 1) }
 
-    context 'xxx' do
-      before(:each) do
-        kv_stub.put 'foo', 'bar'
+    context 'watch' do
+      it 'should return an event' do 
+        resp = nil
+        thr = Thread.new do |thr|
+          resp = stub.watch("foo", nil, 1, nil)
+        end
+        sleep 2
+        kv_stub.put("foo", "works")
+        thr.join
+        expect(resp).to be_an_instance_of(Google::Protobuf::RepeatedField)
+        expect(resp.last.kv.key).to eq('foo')  
       end
-      it_should_behave_like "a method with a GRPC timeout", described_class, :watch, :watch, 'foo', "\0", 1, nil
     end
   end
 end

data/spec/etcdv3_spec.rb

@@ -293,7 +293,7 @@ describe Etcdv3 do
     describe '#role_grant_permission' do
       before { conn.role_add('grant') }
       after { conn.role_delete('grant') }
-      subject { conn.role_grant_permission('grant', :readwrite, 'a', {range_end: 'Z'}) }
+      subject { conn.role_grant_permission('grant', :readwrite, 'a', **{range_end: 'Z'}) }
       it { is_expected.to_not be_nil }
       it_should_behave_like "Etcdv3 instance using a timeout", :role_grant_permission, 'grant', :readwrite, 'a'
     end
@@ -521,5 +521,261 @@ describe Etcdv3 do
         end
       end
     end
+
+    describe "namespace" do 
+
+      describe '#get' do
+        let(:get_conn) { local_connection_with_namespace("/namespace-get/") }
+
+        before do
+          conn.put('/apples/', 'app')
+          conn.put('/namespace-get/apple', 'apple')
+          conn.put('/namespace-get/apples', 'apples')
+          conn.put('/namespace-get/appless', 'appless')
+        end
+
+        it 'returns key w/o namespace' do 
+          expect(get_conn.get("apple").kvs.last.value).to eq('apple')
+        end
+
+        it 'returns keys w/o namespace' do 
+          expect(get_conn.get("apple", range_end: 'applf').kvs.size).to eq(3)
+        end
+
+        it 'returns all keys under namespace' do 
+          expect(get_conn.get("", range_end: "\0").kvs.size).to eq(3)
+        end
+      end
+
+      describe '#put' do
+        let(:put_conn) { local_connection_with_namespace("/namespace-put/") }
+
+        before do
+          put_conn.put('apple_put', 'test')
+        end
+        it 'returns key with namespace' do 
+          expect(conn.get("/namespace-put/apple_put").kvs.last.value).to eq('test')
+        end
+      end
+
+      describe '#del' do 
+        let(:del_conn) { local_connection_with_namespace("/del-test/") }
+        
+        context 'zero-byte' do 
+          before do 
+            del_conn.put('test', "key")
+            del_conn.put('test2', "key2")
+            conn.put('wall', 'zzzz')
+            conn.put('walzz', 'adsfas')
+          end
+
+          it 'deleting all keys should be scoped to namespace' do 
+            resp = del_conn.del("", range_end: "\0")
+            expect(resp.deleted).to eq(2)
+            expect(conn.get("wall").kvs.last.value).to eq('zzzz')
+          end
+        end
+
+        context 'no range' do
+          before { del_conn.put('test', 'value') }
+          subject { del_conn.del('test') }
+          it { is_expected.to_not be_nil }
+        end
+
+        context 'ranged del' do
+          before do
+            del_conn.put('test', 'value')
+            del_conn.put('testt', 'value')
+          end
+          subject { del_conn.del('test', range_end: 'testtt') }
+          it { is_expected.to_not be_nil }
+        end
+      end
+
+      describe '#transaction' do
+        let(:trans_conn) { local_connection_with_namespace("/namespace/") }
+
+        describe 'txn.value' do
+          before { trans_conn.put('txn', 'value') }
+          after { trans_conn.del('txn') }
+          context 'success' do
+            subject! do
+              trans_conn.transaction do |txn|
+                txn.compare = [ txn.value('txn', :equal, 'value') ]
+                txn.success = [ txn.put('txn-test', 'success') ]
+                txn.failure = [ txn.put('txn-test', 'failed') ]
+              end
+            end
+            it 'sets correct key' do
+              expect(trans_conn.get('txn-test').kvs.first.value).to eq('success')
+              expect(conn.get("/namespace/txn-test").kvs.first.value).to eq('success')
+            end
+            it "raises a GRPC::DeadlineExceeded exception when it takes too long"  do
+              expect do
+                trans_conn.transaction(timeout: 0) do |txn|
+                  txn.compare = [ txn.value('txn', :equal, 'value') ]
+                  txn.success = [ txn.put('txn-test', 'success') ]
+                  txn.failure = [ txn.put('txn-test', 'failed') ]
+                end
+              end.to raise_exception(GRPC::DeadlineExceeded)
+            end
+            it "accepts a timeout" do
+              expect do
+                trans_conn.transaction(timeout: 1) do |txn|
+                  txn.compare = [ txn.value('txn', :equal, 'value') ]
+                  txn.success = [ txn.put('txn-test', 'success') ]
+                  txn.failure = [ txn.put('txn-test', 'failed') ]
+                end
+              end.to_not raise_exception
+            end
+          end
+          context "success, value with lease" do
+            let!(:lease_id) { trans_conn.lease_grant(2)['ID'] }
+            subject! do
+              trans_conn.transaction do |txn|
+                txn.compare = [ txn.value('txn', :equal, 'value') ]
+                txn.success = [ txn.put('txn-test', 'success', lease_id) ]
+                txn.failure = [ txn.put('txn-test', 'failed', lease_id) ]
+              end
+            end
+            it 'sets correct key, with a lease' do
+              expect(trans_conn.get('txn-test').kvs.first.value).to eq('success')
+              expect(trans_conn.get('txn-test').kvs.first.lease).to eq(lease_id)
+            end
+          end
+          context 'failure' do
+            subject! do
+              trans_conn.transaction do |txn|
+                txn.compare = [ txn.value('txn', :equal, 'notright') ]
+                txn.success = [ txn.put('txn-test', 'success') ]
+                txn.failure = [ txn.put('txn-test', 'failed') ]
+              end
+            end
+            it 'sets correct key' do
+              expect(trans_conn.get('txn-test').kvs.first.value).to eq('failed')
+            end
+          end
+        end
+  
+        describe 'txn.create_revision' do
+          before { trans_conn.put('txn', 'value') }
+          after { trans_conn.del('txn') }
+          context 'success' do
+            subject! do
+              trans_conn.transaction do |txn|
+                txn.compare = [ txn.create_revision('txn', :greater, 1) ]
+                txn.success = [ txn.put('txn-test', 'success') ]
+                txn.failure = [ txn.put('txn-test', 'failed') ]
+              end
+            end
+            it 'sets correct key' do
+              expect(trans_conn.get('txn-test').kvs.first.value).to eq('success')
+            end
+          end
+          context 'failure' do
+            subject! do
+              trans_conn.transaction do |txn|
+                txn.compare = [ txn.create_revision('txn', :equal, 1) ]
+                txn.success = [ txn.put('txn-test', 'success') ]
+                txn.failure = [ txn.put('txn-test', 'failed') ]
+              end
+            end
+            it 'sets correct key' do
+              expect(trans_conn.get('txn-test').kvs.first.value).to eq('failed')
+              expect(conn.get('/namespace/txn-test').kvs.first.value).to eq('failed')
+            end
+          end
+        end
+  
+        describe 'txn.mod_revision' do
+          before { trans_conn.put('txn', 'value') }
+          after { trans_conn.del('txn') }
+          context 'success' do
+            subject! do
+              trans_conn.transaction do |txn|
+                txn.compare = [ txn.mod_revision('txn', :less, 1000) ]
+                txn.success = [ txn.put('txn-test', 'success') ]
+                txn.failure = [ txn.put('txn-test', 'failed') ]
+              end
+            end
+            it 'sets correct key' do
+              expect(trans_conn.get('txn-test').kvs.first.value).to eq('success')
+              expect(conn.get('/namespace/txn-test').kvs.first.value).to eq('success')
+            end
+          end
+          context 'failure' do
+            subject! do
+              trans_conn.transaction do |txn|
+                txn.compare = [ txn.mod_revision('txn', :greater, 1000) ]
+                txn.success = [ txn.put('txn-test', 'success') ]
+                txn.failure = [ txn.put('txn-test', 'failed') ]
+              end
+            end
+            it 'sets correct key' do
+              expect(trans_conn.get('txn-test').kvs.first.value).to eq('failed')
+              expect(conn.get('/namespace/txn-test').kvs.first.value).to eq('failed')
+
+            end
+          end
+        end
+  
+        describe 'txn.version' do
+          before { trans_conn.put('txn-version', 'value') }
+          after { trans_conn.del('txn-version') }
+          context 'success' do
+            subject! do
+              trans_conn.transaction do |txn|
+                txn.compare = [ txn.version('txn-version', :equal, 1) ]
+                txn.success = [ txn.put('txn-test', 'success') ]
+                txn.failure = [ txn.put('txn-test', 'failed') ]
+              end
+            end
+            it 'sets correct key' do
+              expect(trans_conn.get('txn-test').kvs.first.value).to eq('success')
+              expect(conn.get('/namespace/txn-test').kvs.first.value).to eq('success')
+            end
+          end
+          context 'failure' do
+            subject! do
+              trans_conn.transaction do |txn|
+                txn.compare = [ txn.version('txn', :equal, 100)]
+                txn.success = [ txn.put('txn-test', 'success') ]
+                txn.failure = [ txn.put('txn-test', 'failed') ]
+              end
+            end
+            it 'sets correct key' do
+              expect(trans_conn.get('txn-test').kvs.first.value).to eq('failed')
+              expect(conn.get('/namespace/txn-test').kvs.first.value).to eq('failed')
+            end
+          end
+        end
+      end
+
+      # Locking is not implemented in etcd v3.1.X
+      unless $instance.version < Gem::Version.new("3.2.0")
+        describe "locking" do 
+          let(:ns_conn) { local_connection_with_namespace("/namespace/") }
+
+          describe '#lock' do
+            let(:lease_id) { lease_stub.lease_grant(10)['ID'] }
+            subject { ns_conn.lock('mylocklock', lease_id) }
+            it 'should lock key under specified namespace' do 
+              expect(conn.get("/namespace/#{subject.key}").kvs).to_not be_empty
+            end
+          end
+
+          describe '#with_lock' do
+            let(:lease_id) { lease_stub.lease_grant(10)['ID'] }
+            let(:lease_id_2) { lease_stub.lease_grant(15)['ID'] }
+            it 'enforces lock' do
+              ns_conn.with_lock('mylock', lease_id) do
+                expect { ns_conn.lock('mylock', lease_id_2, timeout: 0.1) }
+                  .to raise_error(GRPC::DeadlineExceeded)
+              end
+            end
+          end
+        end
+      end
+    end
   end
 end

data/spec/helpers/connections.rb

@@ -5,18 +5,34 @@ module Helpers
       Etcdv3.new(endpoints: "http://#{local_url}", user: user, password: password)
     end
 
-    def local_connection(endpoints="http://#{local_url}")
-      Etcdv3.new(endpoints: endpoints)
+    def local_connection(endpoints="http://#{local_url}", allow_reconnect: true)
+      Etcdv3.new(endpoints: endpoints, allow_reconnect: allow_reconnect)
     end
 
     def local_connection_with_timeout(timeout)
       Etcdv3.new(endpoints: "http://#{local_url}", command_timeout: timeout)
     end
 
+    def local_connection_with_namespace(namespace)
+      Etcdv3.new(endpoints: "http://#{local_url}", namespace: namespace)
+    end
+
     def local_stub(interface, timeout=nil)
       interface.new(local_url, :this_channel_is_insecure, timeout, {})
     end
 
+    def local_stub_with_metadata(interface, timeout: nil, metadata: {})
+      interface.new(local_url, :this_channel_is_insecure, timeout, metadata)
+    end
+
+    def local_namespace_stub(interface, timeout=nil, namespace)
+      interface.new(local_url, :this_channel_is_insecure, timeout, namespace, {})
+    end
+
+    def local_namespace_stub_with_metadata(interface, timeout: nil, namespace:, metadata: {})
+      interface.new(local_url, :this_channel_is_insecure, timeout, namespace, metadata)
+    end
+
     def local_url
       "127.0.0.1:#{port}"
     end

data/spec/helpers/metadata_passthrough.rb

@@ -0,0 +1,21 @@
+module Helpers
+  module MetadataPassthrough
+    include Connections
+
+    def expect_metadata_passthrough(stub_class, method_name, expectation_target)
+      metadata = { user: "foo", password: "bar" }
+      handler = local_stub_with_metadata(stub_class, metadata: metadata, timeout: 1)
+      inner_stub = handler.instance_variable_get("@stub")
+      expect(inner_stub).to receive(expectation_target).with(anything, hash_including(metadata: metadata)).and_call_original
+      return handler
+    end
+
+    def expect_metadata_passthrough_namespace(stub_class, method_name, expectation_target, namespace)
+      metadata = { user: "foo", password: "bar" }
+      handler = local_namespace_stub_with_metadata(stub_class, metadata: metadata, timeout: 1, namespace: namespace)
+      inner_stub = handler.instance_variable_get("@stub")
+      expect(inner_stub).to receive(expectation_target).with(anything, hash_including(metadata: metadata)).and_call_original
+      return handler
+    end
+  end
+end

data/spec/helpers/shared_examples_for_timeout.rb

@@ -32,13 +32,13 @@ shared_examples_for "Etcdv3 instance using a timeout" do |command, *args|
   it "raises a GRPC::DeadlineExceeded exception when it takes too long"  do
     expect do
       test_args = args.dup
-      test_args.push({timeout: 0})
-      conn.public_send(command, *test_args)
+      test_kwargs = {timeout: 0}
+      conn.public_send(command, *test_args, **test_kwargs)
     end.to raise_exception(GRPC::DeadlineExceeded)
   end
   it "accepts a timeout" do
     test_args = args.dup
-    test_args.push({timeout: 10})
-    expect{ conn.public_send(command, *test_args) }.to_not raise_exception
+    test_kwargs = {timeout: 10}
+    expect{ conn.public_send(command, *test_args, **test_kwargs) }.to_not raise_exception
   end
 end

data/spec/helpers/test_instance.rb

@@ -3,10 +3,12 @@ require 'tmpdir'
 require 'socket'
 require 'timeout'
 require 'helpers/connections'
+require 'helpers/metadata_passthrough'
 
 module Helpers
   class TestInstance
     include Helpers::Connections
+    include Helpers::MetadataPassthrough
 
     class InvalidVersionException < StandardError; end
     class PortInUseException < StandardError; end