snmpjr 0.2.2-java → 0.3.0-java

data/spec/integration/snmp_v3/snmpjr_get_spec.rb

@@ -0,0 +1,67 @@
+require 'snmpjr'
+require 'snmpjr/response'
+require 'snmpjr/session_v3'
+
+describe "snmpjr for snmp v3" do
+
+  describe 'GET' do
+    subject { Snmpjr.new(Snmpjr::Version::V3) }
+
+    context 'when the host is reachable' do
+      before do
+        subject.configure do |config|
+          config.host = 'demo.snmplabs.com'
+          config.user = 'usr-sha-aes128'
+          config.authentication 'SHA', 'authkey1'
+          config.privacy 'AES128', 'privkey1'
+        end
+      end
+
+      it 'can perform a simple synchronous get request on an snmp agent' do
+        expect(subject.get '1.3.6.1.2.1.1.1.0').to eq Snmpjr::Response.new(oid: '1.3.6.1.2.1.1.1.0', value: 'SunOS zeus.snmplabs.com 4.1.3_U1 1 sun4m')
+      end
+
+      let(:expected) { [Snmpjr::Response.new(oid: '1.3.6.1.2.1.1.1.0', value: 'SunOS zeus.snmplabs.com 4.1.3_U1 1 sun4m'),
+                        Snmpjr::Response.new(oid: '1.3.6.1.2.1.1.5.0', value: 'zeus.snmplabs.com')] }
+      it 'can perform a series of gets if passed an array of oids' do
+        expect(subject.get ['1.3.6.1.2.1.1.1.0', '1.3.6.1.2.1.1.5.0']).to eq expected
+      end
+
+     context "when an invalid oid is requested" do
+        before do
+          subject.configure do |config|
+            config.host = 'demo.snmplabs.com'
+            config.user = 'usr-sha-des'
+            config.authentication 'SHA', 'authkey1'
+            config.privacy 'DES', 'privkey1'
+          end
+        end
+
+        let(:expected) { [Snmpjr::Response.new(oid: '1.3.6.1.2.1.1.5', error: 'noSuchInstance'),
+                          Snmpjr::Response.new(oid: '1.3.6.1.2.1.1.5.0', value: 'zeus.snmplabs.com')] }
+
+        it 'returns an error' do
+          expect(subject.get ['1.3.6.1.2.1.1.5', '1.3.6.1.2.1.1.5.0']).to eq expected
+        end
+      end
+    end
+
+    context 'when the host is unreachable' do
+      before do
+        subject.configure do |config|
+          config.host = 'demo.snmplabs.com'
+          config.port = 161
+          config.user = 'usr-sha-des'
+          config.authentication 'SHA', 'authkey1'
+          config.timeout = 50
+        end
+      end
+
+      it 'the request times out after 5 seconds' do
+        expect{
+          subject.get '1.3.6.1.2.1.1.1.0'
+        }.to raise_error(Snmpjr::TargetTimeoutError)
+      end
+    end
+  end
+end

data/spec/integration/snmp_v3/snmpjr_walk_spec.rb

@@ -0,0 +1,54 @@
+require 'snmpjr'
+require 'snmpjr/response'
+require 'snmpjr/session_v3'
+
+describe "snmpjr for snmp v3" do
+
+  describe 'WALK' do
+    subject { Snmpjr.new(Snmpjr::Version::V3) }
+
+    context 'when the host is reachable' do
+      before do
+        subject.configure do |config|
+          config.host = 'demo.snmplabs.com'
+          config.port = 161
+          config.context = '80004fb805636c6f75644dab22cc'
+          config.user = 'usr-none-none'
+        end
+      end
+
+      it 'can perform a simple synchronous walk request on an snmp agent' do
+        response = subject.walk '1.3.6.1.2.1.1'
+        expect(response.count).to eq 11
+        expect(response.first.to_s).to eq 'SunOS zeus.snmplabs.com 4.1.3_U1 1 sun4m'
+        expect(response.last.to_s).to match(/^\d+\:\d+:\d+\.\d+$/)
+      end
+
+      context "when a non existent subtree is walked" do
+        it 'returns an empty array' do
+          expect(subject.walk '1.3.6.1.5').to eq []
+        end
+      end
+    end
+
+    context 'when the host is unreachable' do
+      before do
+        subject.configure do |config|
+          config.host = 'demo.snmplabs.com'
+          config.port = 161
+          config.context = '80004fb805636c6f75644dab22cc'
+          config.user = 'usr-sha-aes256'
+          config.authentication 'SHA', 'authkey1'
+          config.privacy 'AES256', 'privkey1'
+          config.timeout = 50
+        end
+      end
+
+      it 'the request times out after 5 seconds' do
+        expect{
+          subject.walk '1.3.6.1.2.1.1'
+        }.to raise_error(Snmpjr::TargetTimeoutError)
+      end
+    end
+  end
+end

data/spec/snmpjr/configuration_v2c_spec.rb

@@ -0,0 +1,30 @@
+require production_code
+
+describe Snmpjr::ConfigurationV2C do
+  describe '#create_pdu' do
+    it 'creates a new PduV2 instance' do
+      expect(subject.create_pdu).to be_a Snmpjr::PduV2C
+    end
+  end
+
+  describe '#create_target' do
+    let(:target) { double :target }
+    let(:created_target) { double :created_target }
+
+    before do
+      allow(Snmpjr::TargetV2C).to receive(:new).and_return target
+      allow(target).to receive(:create).with(subject).and_return created_target
+    end
+
+    it 'creates a target for snmp v2' do
+      subject.create_target
+      expect(subject.create_target).to eq created_target
+    end
+  end
+
+  describe '#create_session' do
+    it 'creates a session for snmp v2' do
+      expect(subject.create_session).to be_a Snmpjr::SessionV2C
+    end
+  end
+end

data/spec/snmpjr/configuration_v3_spec.rb

@@ -0,0 +1,90 @@
+require production_code
+
+describe Snmpjr::ConfigurationV3 do
+  describe '#authentication' do
+    it 'sets the authentication protocol' do
+      subject.authentication 'MD5', 'test1234'
+      expect(subject.authentication_protocol).to eq 'MD5'
+    end
+
+    it 'sets the authentication key' do
+      subject.authentication 'MD5', 'test1234'
+      expect(subject.authentication_key).to eq 'test1234'
+    end
+  end
+
+  describe '#privacy' do
+    it 'sets the privacy protocol' do
+      subject.privacy 'AES256', 'test1234'
+      expect(subject.privacy_protocol).to eq 'AES256'
+    end
+
+    it 'sets the privacy key' do
+      subject.privacy 'AES256', 'test1234'
+      expect(subject.privacy_key).to eq 'test1234'
+    end
+  end
+
+  describe '#create_pdu' do
+    it 'creates a new PduV3 instance' do
+      expect(subject.create_pdu).to be_a Snmpjr::PduV3
+    end
+
+    it 'assigns a context to it' do
+      subject.context = 'some_context'
+      expect(Snmpjr::PduV3).to receive(:new).with('some_context')
+      subject.create_pdu
+    end
+  end
+
+  describe '#security_level' do
+    context 'noAuthNoPriv' do
+      it 'sets the security level to NoAuthNoPriv if no authentication or privacy are set' do
+        expect(subject.security_level).to eq Snmpjr::ConfigurationV3::SecurityLevels::NoAuthNoPriv
+      end
+    end
+
+    context 'authNoPriv' do
+      it 'sets the security level to no authNoPriv if authentication but no privacy is set' do
+        subject.authentication 'MD5', 'test1234'
+        expect(subject.security_level).to eq Snmpjr::ConfigurationV3::SecurityLevels::AuthNoPriv
+      end
+    end
+
+    context 'authPriv' do
+      it 'sets the security level to authPriv if both authentication and privacy are set' do
+        subject.authentication 'MD5', 'test1234'
+        subject.privacy 'AES256', 'test1234'
+        expect(subject.security_level).to eq Snmpjr::ConfigurationV3::SecurityLevels::AuthPriv
+      end
+    end
+  end
+
+  describe '#create_target' do
+    let(:target) { double :target }
+    let(:created_target) { double :created_target }
+
+    before do
+      allow(Snmpjr::TargetV3).to receive(:new).and_return target
+      allow(target).to receive(:create).with(subject).and_return created_target
+    end
+
+    it 'creates a target for snmp v3' do
+      subject.create_target
+      expect(subject.create_target).to eq created_target
+    end
+  end
+
+  describe '#create_session' do
+    let(:created_session) { double :created_session }
+
+    before do
+      allow(Snmpjr::SessionV3).to receive(:new).with(subject).and_return created_session
+    end
+
+    it 'creates a session for snmp v3' do
+      subject.create_session
+      expect(subject.create_session).to eq created_session
+    end
+  end
+end

data/spec/snmpjr/getter_spec.rb

@@ -1,63 +1,60 @@
 require production_code
+require 'snmpjr/configuration'
 
 describe Snmpjr::Getter do
   let(:target) { double :target }
-  let(:session) { double Snmpjr::Session }
-  let(:pdu) { double Snmpjr::Pdu }
+  let(:session) { double :session }
+  let(:pdu) { double :pdu }
   let(:created_pdu_single) { double :created_pdu_single }
 
-  subject { described_class.new(target: target, max_oids_per_request: 1) }
+  let(:configuration) { Snmpjr::Configuration.new }
+
+  subject { described_class.new(session: session, target: target, pdu: pdu, config: configuration) }
 
   before do
-    allow(Snmpjr::Pdu).to receive(:new).and_return pdu
-    allow(pdu).to receive(:create).with(['1.2.3.4.5.6']).and_return created_pdu_single
-    allow(Snmpjr::Session).to receive(:new).and_return session
     allow(session).to receive(:start)
     allow(session).to receive(:send).with(created_pdu_single, target).and_return ['Foo']
     allow(session).to receive(:close)
   end
 
-  describe '#get_multiple' do
+  describe '#get' do
     let(:created_pdu_multiple_1) { double :created_pdu_multiple_1 }
     let(:created_pdu_multiple_2) { double :created_pdu_multiple_2 }
 
     before do
+      configuration.max_oids_per_request = 1
       allow(pdu).to receive(:create).with(['1.2.3.4.5.6']).and_return created_pdu_multiple_1
       allow(pdu).to receive(:create).with(['6.5.4.3.2.1']).and_return created_pdu_multiple_2
       allow(session).to receive(:send).with(created_pdu_multiple_1, target).and_return ['Foo']
       allow(session).to receive(:send).with(created_pdu_multiple_2, target).and_return ['Bar']
     end
 
-    it 'starts an snmp session' do
-      subject.get_multiple ['1.2.3.4.5.6', '6.5.4.3.2.1']
-      expect(session).to have_received(:start)
-    end
+    context 'when there is a single oid' do
+      before do
+        allow(pdu).to receive(:create).with(['1.2.3.4.5.6']).and_return created_pdu_single
+      end
 
-    it 'performs multiple gets for each oid' do
-      expect(subject.get_multiple ['1.2.3.4.5.6', '6.5.4.3.2.1']).to eq(['Foo', 'Bar'])
-      expect(session).to have_received(:send).with(created_pdu_multiple_1, target)
-      expect(session).to have_received(:send).with(created_pdu_multiple_2, target)
+      it 'performs a synchronous get' do
+        expect(subject.get ['1.2.3.4.5.6']).to eq 'Foo'
+        expect(session).to have_received(:send).with(created_pdu_single, target)
+      end
     end
 
-    it 'closes the snmp session' do
-      subject.get_multiple ['1.2.3.4.5.6', '6.5.4.3.2.1']
-      expect(session).to have_received(:close)
+    context 'when there are multiple oids' do
+      it 'performs multiple gets for each oid' do
+        expect(subject.get ['1.2.3.4.5.6', '6.5.4.3.2.1']).to eq(['Foo', 'Bar'])
+        expect(session).to have_received(:send).with(created_pdu_multiple_1, target)
+        expect(session).to have_received(:send).with(created_pdu_multiple_2, target)
+      end
     end
-  end
 
-  describe '#get' do
     it 'starts an snmp session' do
-      subject.get '1.2.3.4.5.6'
+      subject.get ['1.2.3.4.5.6', '6.5.4.3.2.1']
       expect(session).to have_received(:start)
     end
 
-    it 'performs a synchronous get' do
-      expect(subject.get '1.2.3.4.5.6').to eq 'Foo'
-      expect(session).to have_received(:send).with(created_pdu_single, target)
-    end
-
     it 'closes the snmp session' do
-      subject.get '1.2.3.4.5.6'
+      subject.get ['1.2.3.4.5.6', '6.5.4.3.2.1']
       expect(session).to have_received(:close)
     end
   end

data/spec/snmpjr/{pdu_spec.rb → pdu_v2c_spec.rb}

@@ -1,6 +1,6 @@
 require production_code
 
-describe Snmpjr::Pdu do
+describe Snmpjr::PduV2C do
   describe '#create' do
 
     let(:pdu) { double Snmpjr::Wrappers::PDU }
@@ -19,7 +19,7 @@ describe Snmpjr::Pdu do
       allow(pdu).to receive(:add)
     end
     it 'creates a GET Pdu' do
-      expect(pdu).to receive(:type=).with(Snmpjr::Pdu::Constants::GET)
+      expect(pdu).to receive(:type=).with(Snmpjr::PduV2C::Constants::GET)
       subject.create ['1.2.3.4']
     end
 

data/spec/snmpjr/pdu_v3_spec.rb

@@ -0,0 +1,17 @@
+require production_code
+
+describe Snmpjr::PduV3 do
+  subject { Snmpjr::PduV3.new 'context' }
+
+  describe '.new' do
+    it 'assigns scoped context name' do
+      expect(subject.create(['1.3.6']).context_name.to_s).to eq 'context'
+    end
+  end
+
+  describe '#create' do
+    it 'creates a scoped Pdu' do
+      expect(subject.create ['1.3.6']).to be_a(Snmpjr::Wrappers::ScopedPDU)
+    end
+  end
+end

data/spec/snmpjr/{session_spec.rb → session_v2c_spec.rb}

@@ -1,6 +1,6 @@
 require production_code
 
-describe Snmpjr::Session do
+describe Snmpjr::SessionV2C do
 
   let(:transport_mapping) { double Snmpjr::Wrappers::Transport::DefaultUdpTransportMapping }
   let(:snmp_session) { double Snmpjr::Wrappers::Snmp }

data/spec/snmpjr/session_v3_spec.rb

@@ -0,0 +1,22 @@
+require production_code
+require 'snmpjr/configuration_v3'
+
+describe Snmpjr::SessionV3 do
+  describe '.new' do
+    it 'creates and attaches the correct user security model (usm)' do
+      config = Snmpjr::ConfigurationV3.new
+      config.host = 'demo.snmplabs.com'
+      config.port = 161
+      config.user = 'usr-sha-des'
+      config.authentication 'SHA', 'authkey1'
+      config.privacy 'DES', 'privkey1'
+
+      session = described_class.new config
+
+      expect(session.snmp.usm.user_table.user_entries.first.usm_user.security_name.to_s).to eq 'usr-sha-des'
+      expect(session.snmp.usm.user_table.user_entries.first.usm_user.privacy_passphrase.to_s).to eq 'privkey1'
+      expect(session.snmp.usm.user_table.user_entries.first.usm_user.authentication_passphrase.to_s).to eq 'authkey1'
+
+    end
+  end
+end

data/spec/snmpjr/{target_spec.rb → target_v2c_spec.rb}

@@ -1,18 +1,27 @@
+require 'snmpjr/configuration_v2c'
 require production_code
 
-describe Snmpjr::Target do
+describe Snmpjr::TargetV2C do
 
   describe '#create' do
-    let(:options) { { host: '127.0.0.1', port: 161, community: 'some_community', timeout: 50, retries: 2 } }
+    let(:configuration) do
+      config = Snmpjr::ConfigurationV2C.new
+      config.host = '127.0.0.1'
+      config.port = 161
+      config.community = 'some community'
+      config.retries = 2
+      config.timeout = 50
+      config
+    end
 
     it 'creates an octet string for the community string' do
-      expect(Snmpjr::Wrappers::SMI::OctetString).to receive(:new).with(options[:community])
-      subject.create(options)
+      expect(Snmpjr::Wrappers::SMI::OctetString).to receive(:new).with(configuration.community)
+      subject.create(configuration)
     end
 
     it 'creates an smi address based on the ip and port name' do
       expect(Snmpjr::Wrappers::SMI::GenericAddress).to receive(:parse).with("udp:127.0.0.1/161")
-      subject.create(options)
+      subject.create(configuration)
     end
 
     let(:community_target) { double Snmpjr::Wrappers::CommunityTarget }
@@ -30,11 +39,11 @@ describe Snmpjr::Target do
       expect(community_target).to receive(:version=).with(1)
       expect(community_target).to receive(:timeout=).with(50)
       expect(community_target).to receive(:retries=).with(2)
-      subject.create(options)
+      subject.create(configuration)
     end
 
     it 'returns the SNMP4J community target' do
-      expect(subject.create(options).class).to eq community_target.class
+      expect(subject.create(configuration)).to eq(community_target)
     end
   end
 end

data/spec/snmpjr/target_v3_spec.rb

@@ -0,0 +1,50 @@
+require 'snmpjr/configuration_v3'
+require production_code
+
+describe Snmpjr::TargetV3 do
+
+  describe '#create' do
+    let(:configuration) do
+      config = Snmpjr::ConfigurationV3.new
+      config.host = '127.0.0.1'
+      config.port = 161
+      config.retries = 2
+      config.context = '80004fb805636c6f75644dab22cc'
+      config.user = 'username'
+      config.authentication 'SHA', 'authkey1'
+      config.privacy 'DES', 'privkey1'
+      config.timeout = 50
+      config
+    end
+
+    it 'returns the SNMP4J user target' do
+      expect(subject.create(configuration)).to be_a(Snmpjr::Wrappers::UserTarget)
+    end
+
+    let(:target) { subject.create(configuration) }
+
+    specify 'the user target has the correct host and port' do
+      expect(target.address.to_s).to eq('127.0.0.1/161')
+    end
+
+    specify 'the user target has the correct retries' do
+      expect(target.retries).to eq 2
+    end
+
+    specify 'the user target has the correct timeout' do
+      expect(target.timeout).to eq 50
+    end
+
+    specify 'the user was created with the correct user' do
+      expect(target.security_name.to_s).to eq 'username'
+    end
+
+    it 'sets the snmp version to 3' do
+      expect(target.version).to eq Snmpjr::Version::V3
+    end
+
+    it 'sets the security level' do
+      expect(target.security_level).to eq Snmpjr::ConfigurationV3::SecurityLevels::AuthPriv
+    end
+  end
+end

data/spec/snmpjr/walker_spec.rb

@@ -8,7 +8,7 @@ describe Snmpjr::Walker do
   let(:pdu_factory) { double Snmpjr::Wrappers::Util::DefaultPDUFactory }
   let(:tree_util) { double Snmpjr::Wrappers::Util::TreeUtils }
 
-  subject { described_class.new(target: target) }
+  subject { described_class.new(target: target, session: session) }
 
   let(:vb1) { Snmpjr::Wrappers::SMI::VariableBinding.new(
     Snmpjr::Wrappers::SMI::OID.new('1.3.6'),
@@ -25,7 +25,6 @@ describe Snmpjr::Walker do
 
   before do
     allow(Snmpjr::Wrappers::Util::DefaultPDUFactory).to receive(:new).and_return pdu_factory
-    allow(Snmpjr::Session).to receive(:new).and_return session
 
     allow(Snmpjr::Wrappers::Util::TreeUtils).to receive(:new).with(session.snmp, pdu_factory).and_return tree_util
     allow(tree_util).to receive(:getSubtree).with(target, oid).and_return example_event_responses

data/spec/snmpjr_spec.rb

@@ -1,47 +1,88 @@
 require production_code
 
 describe Snmpjr do
-  let(:target) { double Snmpjr::Target }
-  let(:community_target) { double :community_target }
-  let(:agent_details) { { host: '127.0.0.1', port: 161, community: 'some_community', timeout: 50, retries: 50 } }
+  let(:target) { double :target }
+  let(:configuration) { double :configuration }
+  let(:created_target) { double :created_target }
+  let(:created_pdu) { double :created_pdu }
+  let(:created_session) { double :created_session }
 
-  subject { described_class.new(agent_details) }
+  subject { described_class.new(Snmpjr::Version::V2C) }
 
   before do
-    allow(Snmpjr::Target).to receive(:new).and_return target
-    allow(target).to receive(:create).with(agent_details).and_return community_target
+    allow(configuration).to receive(:create_target).and_return created_target
+    allow(configuration).to receive(:create_pdu).and_return created_pdu
+    allow(configuration).to receive(:create_session).and_return created_session
+  end
+
+  describe "#configuration" do
+    context "when we are working with SNMP V2" do
+      it "returns a Configuration for SNMP V2" do
+        expect(described_class.new(Snmpjr::Version::V2C).configuration).to be_a(Snmpjr::ConfigurationV2C)
+      end
+    end
+
+    context "when we are working with SNMP V3" do
+      it "returns a Configuration for SNMP V3" do
+        expect(described_class.new(Snmpjr::Version::V3).configuration).to be_a(Snmpjr::ConfigurationV3)
+      end
+    end
+  end
+
+  describe "#configure" do
+    context "when we are working with SNMP V2" do
+      it "yields an Snmpjr V2C configuration" do
+        expect {|block|
+          Snmpjr.new(Snmpjr::Version::V2C).configure(&block)
+        }.to yield_control
+        Snmpjr.new(Snmpjr::Version::V2C).configure do |config|
+          expect(config).to be_a(Snmpjr::ConfigurationV2C)
+        end
+      end
+    end
+
+    context "when we are working with SNMP V3" do
+      it "yields an Snmpjr V3 configuration" do
+        expect {|block|
+          Snmpjr.new(Snmpjr::Version::V3).configure(&block)
+        }.to yield_control
+        Snmpjr.new(Snmpjr::Version::V3).configure do |config|
+          expect(config).to be_a(Snmpjr::ConfigurationV3)
+        end
+      end
+    end
+
+    it 'returns an instance of Snmpjr' do
+      result = Snmpjr.new(Snmpjr::Version::V3).configure do |config|
+        config.user = 'some_user'
+      end
+      expect(result).to be_a(Snmpjr)
+    end
   end
 
   describe "#get" do
     let(:getter) { double Snmpjr::Getter }
 
     before do
-      allow(Snmpjr::Getter).to receive(:new).with(target: community_target, max_oids_per_request: 20).and_return getter
+      allow(Snmpjr::ConfigurationV2C).to receive(:new).and_return configuration
+      allow(Snmpjr::ConfigurationV3).to receive(:new).and_return configuration
+      allow(Snmpjr::Getter).to receive(:new).with(session: created_session, target: created_target, pdu: created_pdu, config: configuration).and_return getter
+      allow(getter).to receive(:get)
     end
 
-    subject { described_class.new(agent_details.merge({max_oids_per_request: 20})) }
-
     context 'when passed a single oid' do
-      it 'performs a synchronous get' do
-        expect(getter).to receive(:get).with('1.2.3.4.5.6')
+      it 'coerces the single oid to an array and gives it to the getter' do
+        expect(getter).to receive(:get).with(['1.2.3.4.5.6'])
         subject.get '1.2.3.4.5.6'
       end
     end
 
     context 'when passed multiple oids' do
-      it 'performs a get multiple using the getter' do
-        expect(getter).to receive(:get_multiple).with(['1.2.3.4.5.6', '6.5.4.3.2.1'])
+      it 'performs a get with the getter' do
+        expect(getter).to receive(:get).with(['1.2.3.4.5.6', '6.5.4.3.2.1'])
         subject.get ['1.2.3.4.5.6', '6.5.4.3.2.1']
       end
     end
-
-    context 'when an invalid argument was passed in' do
-      it 'raises an ArgumentError' do
-        expect {
-          subject.get({'oid_value' => '1.3.4.5.6'})
-        }.to raise_error ArgumentError
-      end
-    end
   end
 
   describe '#walk' do
@@ -49,23 +90,15 @@ describe Snmpjr do
     let(:oid) { double :oid }
 
     before do
-      allow(Snmpjr::Walker).to receive(:new).with(target: community_target).and_return walker
+      allow(Snmpjr::ConfigurationV2C).to receive(:new).and_return configuration
+      allow(Snmpjr::Walker).to receive(:new).with(session: created_session, target: created_target, pdu: created_pdu).and_return walker
       allow(Snmpjr::Wrappers::SMI::OID).to receive(:new).with('1.3.6.1.1').and_return oid
-    end
-    context 'when a string is passed' do
-      it 'performs a synchronous walk' do
-        expect(walker).to receive(:walk).with(oid)
-        subject.walk '1.3.6.1.1'
-      end
+      allow(walker).to receive(:walk)
     end
 
-    context 'when anything else is passed in' do
-      it 'raises an ArgumentError' do
-        expect {
-          subject.walk({'oid_value' => '1.3.4.5.6'})
-        }.to raise_error ArgumentError
-      end
+    it 'performs a synchronous walk' do
+      expect(walker).to receive(:walk).with(oid)
+      subject.walk '1.3.6.1.1'
     end
-
   end
 end