snmp 0.4.0

data/test/test_ber.rb

@@ -0,0 +1,236 @@
+require 'test/unit'
+require 'snmp/ber'
+
+class ASN1_Test < Test::Unit::TestCase
+
+    include SNMP::BER
+
+    def test_decode_tlv_empty
+        tag, value, data = decode_tlv("\001\000")
+        assert_equal(1, tag)
+        assert_equal("", value)
+        assert_equal("", data)
+
+        tag, value, data = decode_tlv("\001\000\111")
+        assert_equal(1, tag)
+        assert_equal("", value)
+        assert_equal("\111", data)
+    end
+    
+    # Decode TLV data with the short-format length field.
+    def test_decode_tlv_short
+        tag, value, data = decode_tlv("\001\002\023\044")
+        assert_equal(1, tag)
+        assert_equal("\023\044", value)
+        assert_equal("", data)
+    end
+    
+    # Extra bytes of data are returned.
+    def test_decode_tlv_short_extra
+        tag, value, data = decode_tlv("\001\002\023\044\000")
+        assert_equal(1, tag)
+        assert_equal("\023\044", value)
+        assert_equal("\000", data)
+    end
+
+    # Decode TLV data with long-format length field
+    def test_decode_tlv_long
+        long_data = ""; 128.times { |i| long_data << i.chr }
+        tag, value, data = decode_tlv("\001\201\200" + long_data)
+        assert_equal(1, tag)
+        assert_equal(long_data, value)
+        assert_equal("", data)
+    end
+        
+    # Long format with extra bytes - use four bytes for length
+    def test_decode_tlv_long_extra
+        long_data = ""; 129.times { |i| long_data << i.chr }
+        tag, value, data = decode_tlv("\001\204\000\000\000\201" + long_data + "\123\123\123")
+        assert_equal(1, tag)
+        assert_equal(long_data, value)
+        assert_equal("\123\123\123", data)
+    end
+
+    # Check invalid length - ASN.1 says that first length octet can't be 255.
+    def test_bad_length
+        assert_raise(InvalidLength) {
+            decode_tlv("\001\377\001")
+        }
+    end
+    
+    # Check if input data is too short
+    def test_out_of_data
+        assert_raise(OutOfData) {
+            decode_tlv("\001\001")
+        }
+        assert_raise(OutOfData) {
+            decode_tlv("\001")
+        }
+        assert_raise(OutOfData) {
+            decode_tlv("")
+        }
+    end
+    
+    # Decode single-octet ASN.1 integer.
+    # Number is negative (2's complement) if high order bit is 1.
+    def test_decode_integer_octet
+        i, data = decode_integer("\002\001\042")
+        assert_equal(34, i)
+        assert_equal("", data)
+        i, data = decode_integer("\002\001\377")
+        assert_equal(-1, i)
+        assert_equal("", data)
+    end
+
+    # Decode multi-octet ASN.1 integer.
+    def test_decode_integer
+        i, data = decode_integer("\002\004\001\002\003\004")
+        assert_equal(16909060, i)
+        assert_equal("", data)
+
+        i, data = decode_integer("\002\004\377\377\377\376")
+        assert_equal(-2, i)
+        assert_equal("", data)
+
+        i, data = decode_integer("\002\003\000\377\376")
+        assert_equal(65534, i)
+        assert_equal("", data)
+        
+        i, data = decode_integer("\002\002\000\377")
+        assert_equal(255, i)
+        assert_equal("", data)
+
+        assert_raise(InvalidTag) {
+            decode_integer("\001\004\001\002\003\004")
+        }
+    end
+
+    def test_decode_timeticks
+        i, data = decode_timeticks("\103\004\001\002\003\004")
+        assert_equal(16909060, i)
+        assert_equal("", data)
+        
+        assert_raise(InvalidTag) {
+            decode_timeticks("\002\004\001\002\003\004")
+        }
+    end
+    
+    # Decode ASN.1 octet string
+    def test_decode_octet_string
+        s, data = decode_octet_string("\004\202\000\005hello")
+        assert_equal("hello",s)
+        assert_raise(InvalidTag) {
+            decode_octet_string("\005\202\000\005hello")
+        }
+    end
+    
+    def test_decode_ip_address
+        ip, data = decode_ip_address("@\004\001\002\003\004")
+        assert_equal(ip, "\001\002\003\004")
+        assert_raise(InvalidTag) {
+            decode_ip_address("\004\004\001\002\003\004")
+        }
+        assert_raise(InvalidLength) {
+            decode_ip_address("@\005\001\002\003\004\005")
+        }
+    end
+    
+    # Decode ASN.1 sequence
+    def test_decode_sequence
+        seq, data = decode_sequence("\060\003\002\001\077")
+        assert_equal("\002\001\077", seq)
+        assert_equal("", data)
+        
+        seq, data = decode_sequence("\060\003\002\001\077\002\001\001")
+        assert_equal("\002\001\077", seq)
+        assert_equal("\002\001\001", data)
+        
+        assert_raise(InvalidTag) {
+            decode_sequence("\061\003\002\001\077")
+        }
+    end
+    
+    def test_decode_object_id
+        # Handle an empty object identifier because net-snmp does it and
+        # they probably had a good reason.
+        object_id, remainder = decode_object_id("\006\000")
+        assert_equal([], object_id)
+        assert_equal("", remainder)
+        
+        object_id, remainder = decode_object_id("\006\001+")
+        assert_equal([1,3], object_id);
+        assert_equal("", remainder)
+
+        object_id, remainder = decode_object_id("\006\002+\006")
+        assert_equal([1,3,6], object_id);
+        assert_equal("", remainder)
+
+        object_id, remainder = decode_object_id("\006\003+\202\001")
+        assert_equal([1,3,257], object_id);
+        assert_equal("", remainder)
+
+        object_id, remainder = decode_object_id("\006\003S\202\001")
+        assert_equal([2,3,257], object_id);
+        assert_equal("", remainder)
+
+        object_id, remainder = decode_object_id("\006\001\000")
+        assert_equal([0,0], object_id);
+        assert_equal("", remainder)
+
+        assert_raise(InvalidTag) do
+            decode_object_id("\007\001+")
+        end
+    end
+    
+    def test_encode_length
+        assert_equal("\000", encode_length(0))
+        assert_equal("\001", encode_length(1))
+        assert_equal("\177", encode_length(127))
+        assert_equal("\201\200", encode_length(128))
+        assert_equal("\202\002\001", encode_length(513))
+        assert_raise(InvalidLength) { encode_length(-1) }
+    end
+    
+    def test_encode_integer
+        assert_equal("\002\001\000", encode_integer(0))
+        assert_equal("\002\001\001", encode_integer(1))
+        assert_equal("\002\001\177", encode_integer(127))
+        assert_equal("\002\002\000\200", encode_integer(128))
+        assert_equal("\002\002\000\377", encode_integer(255))
+        assert_equal("\002\002\001\000", encode_integer(256))
+        
+        assert_equal("\002\001\377", encode_integer(-1))
+        assert_equal("\002\001\200", encode_integer(-128))
+        assert_equal("\002\002\377\177", encode_integer(-129))
+    end
+    
+    def test_encode_octet_string
+        assert_equal("\004\015Dave was here", encode_octet_string("Dave was here"))
+        assert_equal("\004\000", encode_octet_string(""))
+    end
+    
+    def test_encode_sequence
+        assert_equal("0\015Dave was here", encode_sequence("Dave was here"))
+        assert_equal("0\000", encode_sequence(""))
+    end
+    
+    def test_encode_null
+        assert_equal("\005\000", encode_null)
+    end
+    
+    def test_encode_exception
+        assert_equal("\200\000", encode_exception(0x80))
+    end
+    
+    def test_encode_object_id
+        assert_equal("\006\001" << 80.chr, encode_object_id([2]))
+        assert_equal("\006\001\000", encode_object_id([0,0]))
+        assert_equal("\006\001+", encode_object_id([1,3]))
+        assert_equal("\006\002+\006", encode_object_id([1,3,6]))
+        assert_equal("\006\003+\202\001", encode_object_id([1,3,257]))
+        assert_equal("\006\003" << 82.chr << "\202\001", encode_object_id([2,2,257]))
+        assert_raise(InvalidObjectId) { encode_object_id([3,2,257]) }
+        assert_raise(InvalidObjectId) { encode_object_id([]) }
+    end
+end
+

data/test/test_manager.rb

@@ -0,0 +1,192 @@
+require 'test/unit'
+require 'snmp/manager'
+
+class EchoTransport
+    def initialize(host, port)
+    end
+    
+    def close
+    end
+    
+    def send(data)
+        @data = data
+    end
+    
+    def recv(max_bytes)
+        @data[0,max_bytes]
+    end
+end
+
+class TestManager < Test::Unit::TestCase 
+
+    include SNMP
+    
+    def setup
+        @manager = Manager.new(:Transport => EchoTransport)
+    end
+    
+    def teardown
+        @manager.close
+    end
+    
+    def test_defaults
+        assert_equal('localhost', @manager.config[:Host])
+        assert_equal(161, @manager.config[:Port])
+        assert_equal('public', @manager.config[:WriteCommunity])
+    end
+    
+    def test_community
+        @manager = Manager.new(:WriteCommunity=>'private', :Transport => EchoTransport)
+        assert_equal('public', @manager.config[:Community])
+        assert_equal('private', @manager.config[:WriteCommunity])
+
+        @manager = Manager.new(:Community=>'test', :Transport => EchoTransport)
+        assert_equal('test', @manager.config[:Community])
+        assert_equal('test', @manager.config[:WriteCommunity])
+
+        @manager = Manager.new(:Community=>'test', :WriteCommunity=>'private',
+            :Transport => EchoTransport)
+        assert_equal('test', @manager.config[:Community])
+        assert_equal('private', @manager.config[:WriteCommunity])
+    end
+
+    def test_get
+        response = @manager.get("1.2.3.4")
+        assert_equal("1.2.3.4", response.varbind_list.first.name.to_s)
+        
+        response = @manager.get([ObjectId.new("1.2.3.4"), ObjectId.new("1.2.3.4.5")])
+        assert_equal(ObjectId.new("1.2.3.4.5"), response.varbind_list[1].name)
+    end
+
+    def test_get_next
+        response = @manager.get_next("1.2.3.4")
+        assert_equal("1.2.3.4", response.varbind_list.first.name.to_s)
+        
+        response = @manager.get_next([ObjectId.new("1.2.3.4"), ObjectId.new("1.2.3.4.5")])
+        assert_equal(ObjectId.new("1.2.3.4.5"), response.varbind_list[1].name)
+    end
+        
+    def test_set
+        v0 = VarBind.new("1.3.6.1.3.1.1.1.0", OctetString.new("Hello1"))
+        v1 = VarBind.new("1.3.6.1.3.1.1.1.0", OctetString.new("Hello2"))
+        response = @manager.set([v0, v1])
+        assert_equal("Hello1", response.varbind_list[0].value.to_s)
+        assert_equal("Hello2", response.varbind_list[1].value.to_s)
+    end
+
+    def test_single_set
+        varbind = VarBind.new("1.3.6.1.3.1.1.1.0", OctetString.new("Hello"))
+        response = @manager.set(varbind)
+        assert_equal("Hello", response.varbind_list.first.value.to_s)
+    end
+
+    def test_get_bulk
+        response = @manager.get_bulk(1, 2, ["1.3.6.1.3.1.1.1.0", "1.3.6.1.3.1.1.2.0"])
+        assert(1, response.error_status)
+        assert(2, response.error_index)
+        assert(2, response.varbind_list.length)
+        assert_equal("1.3.6.1.3.1.1.1.0", response.varbind_list[0].name.to_s)
+        assert_equal("1.3.6.1.3.1.1.2.0", response.varbind_list[1].name.to_s)
+    end
+
+    def test_request_id
+        srand(100)
+        id = RequestId.new
+        assert_equal(186422792, id.next)
+        
+        id.force_next(1)
+        assert_equal(1, id.next)
+        
+        id.force_next(RequestId::MAX_REQUEST_ID-1)
+        assert_equal(RequestId::MAX_REQUEST_ID-1, id.next)
+        
+        assert_raise(RuntimeError) { id.force_next(RequestId::MAX_REQUEST_ID) }
+        assert_raise(RuntimeError) { id.force_next(0) }
+    end
+end
+
+class TrapTestTransport
+    include SNMP
+    def initialize(port)
+        @count = 0
+        sys_up_varbind = VarBind.new(ObjectId.new("1.3.6.1.2.1.1.3.0"),
+                                     TimeTicks.new(1234))
+        trap_oid_varbind = VarBind.new(ObjectId.new("1.3.6.1.6.3.1.1.4.1.0"),
+                                       ObjectId.new("1.2.3"))
+        trap = SNMPv2_Trap.new(42, VarBindList.new([sys_up_varbind, trap_oid_varbind]))
+        message = Message.new(:SNMPv2c, "public", trap)
+        @data = message.encode
+    end
+    
+    def close
+    end
+    
+    def recvfrom(max_bytes)
+        @count += 1
+        case @count
+        when 1
+            return @data, "127.0.0.1"
+        when 2
+            Thread.exit
+        else
+            raise "Huh?"
+        end
+    end
+end
+
+
+class TestTrapListener < Test::Unit::TestCase
+    include SNMP
+    
+    def test_init_no_handlers
+        init_called = false
+        m = TrapListener.new(:ServerTransport => TrapTestTransport) do |manager|
+            init_called = true
+        end
+        m.join
+        assert(init_called)
+    end
+    
+    def test_v2c_handler
+        default_called = false
+        v2c_called = false
+        m = TrapListener.new(:ServerTransport => TrapTestTransport) do |manager|
+            manager.on_trap_default { default_called = true }
+            manager.on_trap_v2c { v2c_called = true }
+        end
+        m.join
+        assert(!default_called)
+        assert(v2c_called)
+    end
+    
+    def test_oid_handler
+        default_called = false
+        v2c_called = false
+        oid_called = false
+        m = TrapListener.new(:ServerTransport => TrapTestTransport) do |manager|
+            manager.on_trap("1.2.3") do |trap|
+                assert_equal(ObjectId.new("1.2.3"), trap.trap_oid)
+                assert_equal("127.0.0.1", trap.source_ip)
+                oid_called = true
+            end
+            manager.on_trap_default { default_called = true }
+            manager.on_trap_v2c { v2c_called = true }
+        end
+        m.join
+        assert(!default_called)
+        assert(!v2c_called)
+        assert(oid_called)
+    end
+    
+    def test_reject_wrong_community
+        default_called = false
+        m = TrapListener.new(
+            :Community => "test",
+            :ServerTransport => TrapTestTransport) do |manager|
+            manager.on_trap_default { default_called = true }
+        end
+        m.join
+        assert(!default_called)
+    end
+    
+end

data/test/test_mib.rb

@@ -0,0 +1,66 @@
+require 'snmp/mib'
+require 'test/unit'
+
+module SNMP
+
+class TestMib < Test::Unit::TestCase
+
+    def setup
+        @mib = MIB.new
+        @mib.load_module("SNMPv2-MIB")
+        @mib.load_module("IF-MIB")
+    end
+    
+    def test_name_to_oid
+        oid = @mib.oid("1.2.3.4")
+        assert_equal("1.2.3.4", oid.to_s)
+        
+        oid = @mib.oid("ifTable")
+        assert_equal("1.3.6.1.2.1.2.2", oid.to_s)
+
+        oid = @mib.oid("sysDescr.0")
+        assert_equal("1.3.6.1.2.1.1.1.0", oid.to_s)
+
+        oid = @mib.oid("ifTable.1.23")
+        assert_equal("1.3.6.1.2.1.2.2.1.23", oid.to_s)
+        
+        oid = @mib.oid("IF-MIB::ifTable.1.23")
+        assert_equal("1.3.6.1.2.1.2.2.1.23", oid.to_s)
+        
+        assert_raise(MIB::ModuleNotLoadedError) {
+            @mib.oid("IFMIB::ifTable.1.23")
+        }
+        
+        assert_raise(ArgumentError) {
+            @mib.oid("IF-MIB::")
+        }
+    end
+    
+    def test_varbind_list
+        vb_list = @mib.varbind_list("1.2.3.4")
+        assert_equal(1, vb_list.length)
+        assert_equal("1.2.3.4", vb_list.first.name.to_s)
+
+        vb_list = @mib.varbind_list(["IF-MIB::ifTable.1.23", "1.2.3.4"])
+        assert_equal(2, vb_list.length)
+        assert_equal("1.3.6.1.2.1.2.2.1.23", vb_list.first.name.to_s)
+    end
+    
+    def test_varbind
+        vb = @mib.varbind("1.2.3.4", Null)
+        assert_equal("1.2.3.4", vb.name.to_s)
+        assert_equal(Null, vb.value)
+        
+        vb = @mib.varbind("IF-MIB::ifTable.3.45", Integer.new(2))
+        assert_equal("1.3.6.1.2.1.2.2.3.45", vb.name.to_s)
+        assert_equal(2, vb.value)
+    end
+    
+    def test_list
+        list = MIB.list_imported(/SNMPv2/)
+        assert_equal(4, list.length)
+    end
+    
+end
+
+end