etcdv3 0.9.0 → 0.11.4

data/spec/etcdv3/connection_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Etcdv3::Connection do
 
   describe '#initialize - without metadata' do
-    subject { Etcdv3::Connection.new('http://localhost:2379', 10) }
+    subject { Etcdv3::Connection.new('http://localhost:2379', 10, nil) }
 
     it { is_expected.to have_attributes(endpoint: URI('http://localhost:2379')) }
     it { is_expected.to have_attributes(credentials: :this_channel_is_insecure) }
@@ -22,7 +22,7 @@ describe Etcdv3::Connection do
   end
 
   describe '#initialize - with metadata' do
-    subject { Etcdv3::Connection.new('http://localhost:2379', 10, token: 'token123') }
+    subject { Etcdv3::Connection.new('http://localhost:2379', 10, nil, token: 'token123') }
 
     [:kv, :maintenance, :lease, :watch, :auth].each do |handler|
       let(:handler_stub) { subject.handlers[handler].instance_variable_get(:@stub) }
@@ -37,7 +37,7 @@ describe Etcdv3::Connection do
   end
 
   describe '#refresh_metadata' do
-    subject { Etcdv3::Connection.new('http://localhost:2379', token: 'token123') }
+    subject { Etcdv3::Connection.new('http://localhost:2379', nil, token: 'token123') }
     before { subject.refresh_metadata(token: 'newtoken') }
     [:kv, :maintenance, :lease, :watch, :auth].each do |handler|
       let(:handler_metadata) { subject.handlers[handler].instance_variable_get(:@metadata) }

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/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,23 @@
+require 'spec_helper'
+
+# Locking is not implemented in etcd v3.1.X
+unless $instance.version < Gem::Version.new("3.2.0")
+  describe Etcdv3::Lock do
+    let(:stub) { local_namespace_stub(Etcdv3::Namespace::Lock, 1, '/namespace/') }
+    let(:lease_stub) { local_stub(Etcdv3::Lease, 1) }
+
+    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
+      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) }
+    end
+
+    describe '#unlock' do
+      subject { stub.unlock('foo') }
+      it { is_expected.to be_an_instance_of(V3lockpb::UnlockResponse) }
+    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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+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, 5) }
+    let(:kv_stub) { local_stub(Etcdv3::KV, 1) }
+
+    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
+    end
+  end
+end

data/spec/etcdv3_spec.rb

@@ -181,6 +181,20 @@ describe Etcdv3 do
       end
     end
 
+    describe '#watch' do
+      let!(:foo) { conn.put('foo', 'bar') }
+      subject { conn.watch('foo', start_revision: 1) }
+      it { is_expected.to_not be_nil }
+      it "raises a GRPC::DeadlineExceeded exception when it takes too long"  do
+        expect do
+          conn.watch('foo', timeout: 0)
+        end.to raise_exception(GRPC::DeadlineExceeded)
+      end
+      it "accepts a timeout" do
+        expect{ conn.watch('foo', start_revision: 1, timeout: 10) }.to_not raise_exception
+      end
+    end
+
     describe '#lease_keep_alive_once' do
       let!(:lease_id) { conn.lease_grant(2)['ID'] }
       subject { conn.lease_keep_alive_once(lease_id) }
@@ -279,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
@@ -507,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,26 @@ 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_namespace_stub(interface, timeout=nil, namespace)
+      interface.new(local_url, :this_channel_is_insecure, timeout, namespace, {})
+    end
+
     def local_url
       "127.0.0.1:#{port}"
     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/spec_helper.rb

@@ -1,10 +1,12 @@
 $LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift File.expand_path('./helpers', __FILE__)
+$LOAD_PATH.unshift File.expand_path('./namespace', __FILE__)
 
-require 'simplecov'
-require 'codecov'
-SimpleCov.start
-SimpleCov.formatter = SimpleCov::Formatter::Codecov
+
+# require 'simplecov'
+# require 'codecov'
+# SimpleCov.start
+# SimpleCov.formatter = SimpleCov::Formatter::Codecov
 
 require 'etcdv3'
 require 'helpers/test_instance'