snmp 0.4.0

data/test/test_pdu.rb

@@ -0,0 +1,184 @@
+require 'snmp/pdu'
+require 'test/unit'
+
+class TestProtocol < Test::Unit::TestCase
+
+    include SNMP
+    
+    def test_message_decode_v1
+        message = SNMP::Message.decode("0'\002\001\000\004\006public\240\032\002\002\003\350\002\001\000\002\001\0000\0160\f\006\010+\006\001\002\001\001\001\000\005\000")
+        assert_equal(:SNMPv1, message.version)
+        assert_equal("public", message.community)
+        assert_equal(SNMP::GetRequest, message.pdu.class)
+        varbind_list = message.pdu.varbind_list;
+        assert_equal(1, varbind_list.length)
+        assert_equal([1,3,6,1,2,1,1,1,0], varbind_list.first.name)
+        assert_equal(SNMP::Null, varbind_list.first.value)
+    end
+
+    def test_message_decode_v2c
+        message = SNMP::Message.decode("0)\002\001\001\004\006public\240\034\002\0040\265\020\202\002\001\000\002\001\0000\0160\f\006\010+\006\001\002\001\001\001\000\005\000")
+        assert_equal(:SNMPv2c, message.version)
+        assert_equal("public", message.community)
+        varbind_list = message.pdu.varbind_list;
+        assert_equal(1, varbind_list.length)
+        assert_equal([1,3,6,1,2,1,1,1,0], varbind_list.first.name)
+        assert_equal(SNMP::Null, varbind_list.first.value)
+    end
+    
+    def test_message_decoder_v3
+        assert_raise(SNMP::UnsupportedVersion) do
+            message = SNMP::Message.decode("0>\002\001\0030\021\002\004&\266\342\314\002\003\000\377\343\004\001\004\002\001\003\004\0200\016\004\000\002\001\000\002\001\000\004\000\004\000\004\0000\024\004\000\004\000\240\016\002\004\v\3623\233\002\001\000\002\001\0000\000")
+        end
+    end
+    
+    def test_encode_message
+        varbind = SNMP::VarBind.new([1,3,6,1234], SNMP::OctetString.new("value"))
+        list = SNMP::VarBindList.new
+        list << varbind << varbind;
+        pdu = SNMP::Response.new(12345, list)
+        message = SNMP::Message.new(:SNMPv2c, "public", pdu)
+        assert_equal("07\002\001\001\004\006public\242*\002\00209\002\001\000\002\001\0000\0360\r\006\004+\006\211R\004\005value0\r\006\004+\006\211R\004\005value", message.encode)
+    end
+    
+    def test_get_request_from_single_string
+        request = SNMP::GetRequest.new(42, VarBindList.new(["1.3.6.1"]))
+        assert_equal(42, request.request_id)
+        assert_equal(1, request.varbind_list.length)
+        assert_equal([1,3,6,1], request.varbind_list.first.name)
+        assert_equal(SNMP::Null, request.varbind_list.first.value)
+    end
+    
+    def test_get_request_from_multi_string
+        request = SNMP::GetRequest.new(42, VarBindList.new(["1.3.6.1", "1.3.6.2"]))
+        assert_equal(2, request.varbind_list.length)
+        assert_equal([1,3,6,1], request.varbind_list.first.name)
+    end
+
+    def test_get_request_from_varbind
+        request = GetRequest.new(42, VarBindList.new(VarBind.new([1,3,6,1], Null)))
+        assert_equal(1, request.varbind_list.length)
+        assert_equal([1,3,6,1], request.varbind_list.first.name)
+    end
+    
+    def test_get_next_from_single_string
+        request = SNMP::GetNextRequest.new(42, VarBindList.new("1.3.5.1"))
+        assert_equal(42, request.request_id)
+        assert_equal(1, request.varbind_list.length)
+        assert_equal([1,3,5,1], request.varbind_list.first.name)
+    end
+
+    def test_get_next_from_single_object_id
+        request = SNMP::GetNextRequest.new(42, VarBindList.new([ObjectId.new("1.3.5.1")]))
+        assert_equal(42, request.request_id)
+        assert_equal(1, request.varbind_list.length)
+        assert_equal([1,3,5,1], request.varbind_list.first.name)
+    end
+    
+    def test_each_varbind
+        request = SNMP::GetRequest.new(42, VarBindList.new(["1.3.6.1", "1.3.6.2"]))
+        count = 0
+        request.each_varbind do |v|
+            case count
+            when 0
+                assert_equal(ObjectName.new("1.3.6.1"), v.name)
+            when 1
+                assert_equal(ObjectName.new("1.3.6.2"), v.name)
+            else
+                fail "Unexpected count"
+            end
+            count +=1
+        end
+    end
+
+    def test_get_bulk_create
+        request = SNMP::GetBulkRequest.new(1234, VarBindList.new("1.3.6.2"), 0, 10)
+        assert_equal(1234, request.request_id)
+        assert_equal(0, request.non_repeaters)
+        assert_equal(10, request.max_repetitions)
+        assert_equal(1, request.varbind_list.length)
+        assert_equal("1.3.6.2", request.varbind_list.first.name.to_s)
+    end
+
+    def test_get_bulk_encode
+        request = SNMP::GetBulkRequest.new(1234, VarBindList.new, 0, 10)
+        assert_equal("\245\f\002\002\004\322\002\001\000\002\001\n0\000", request.encode)
+    end
+
+    def test_error_status
+        request = GetRequest.new(42, VarBindList.new("1.3.12.23.4"))
+        assert_equal(:noError, request.error_status)
+        
+        request.error_status = :noCreation
+        assert_equal(:noCreation, request.error_status)
+        
+        request.error_status = 2
+        assert_equal(:noSuchName, request.error_status)
+
+        assert_raise(InvalidErrorStatus) {request.error_status = 42}
+    end
+    
+    def test_snmpv2_trap
+        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]))
+        assert_equal("\247-\002\001*\002\001\000\002\001\0000\"0\016\006\010+\006\001\002\001\001\003\000C\002\004\3220\020\006\n+\006\001\006\003\001\001\004\001\000\006\002*\003", trap.encode)
+        assert_equal(1234, trap.sys_up_time.to_i)
+        assert_equal("1.2.3", trap.trap_oid.to_s)
+    end
+    
+    def test_snmpv2_invalid_trap
+        trap = SNMPv2_Trap.new(42, VarBindList.new([]))
+        assert_raise(InvalidTrapVarbind) { trap.sys_up_time }
+        assert_raise(InvalidTrapVarbind) { trap.trap_oid }
+    end
+    
+    def test_snmpv1_generic_trap
+        trap = SNMPv1_Trap.new(nil, nil, 0, nil, nil, nil)
+        assert_equal(:coldStart, trap.generic_trap)
+        
+        trap.generic_trap = :warmStart
+        assert_equal(:warmStart, trap.generic_trap)
+        
+        trap.generic_trap = 6
+        assert_equal(:enterpriseSpecific, trap.generic_trap)
+        
+        assert_raise(InvalidGenericTrap) { trap.generic_trap = -1 }
+        assert_raise(InvalidGenericTrap) { trap.generic_trap = 7 }
+    end
+    
+    def test_snmpv1_trap_encode
+        enterprise = ObjectId.new("1.3.6.1.123")
+        agent_addr = IpAddress.new("1.2.3.4")
+        generic_trap = :linkDown
+        specific_trap = 0
+        timestamp = TimeTicks.new(1234)
+        varbinds = VarBindList.new([VarBind.new("1.3.6.2", Integer.new(1))])
+        trap = SNMPv1_Trap.new(enterprise, agent_addr, generic_trap, specific_trap, timestamp, varbinds)
+        assert_equal("\244\"\006\004+\006\001{@\004\001\002\003\004\002\001\002\002\001\000C\002\004\3220\n0\010\006\003+\006\002\002\001\001", trap.encode)
+
+        encoded = Message.new(:SNMPv1, "public", trap).encode
+        trap = Message.decode(encoded).pdu
+        assert_equal(enterprise, trap.enterprise)
+        assert_equal(agent_addr, trap.agent_addr)
+        assert_equal(:linkDown, trap.generic_trap)
+        assert_equal(0, trap.specific_trap)
+        assert_equal(1, trap.varbind_list.length)
+        assert_equal(ObjectId.new("1.3.6.2"), trap.varbind_list.first.name)
+    end
+    
+    def test_response_pdu
+        pdu = Response.new(2147483647, VarBindList.new, :noError, 0)
+        assert_equal("\242\016\002\004\177\377\377\377\002\001\000\002\001\0000\000", pdu.encode)
+        
+        encoded = Message.new(:SNMPv2c, "public", pdu).encode
+        pdu = Message.decode(encoded).pdu
+        assert_equal(2147483647, pdu.request_id)
+        assert_equal(:noError, pdu.error_status)
+        assert_equal(0, pdu.error_index)
+        assert_equal(0, pdu.varbind_list.length)
+    end
+    
+end

data/test/test_varbind.rb

@@ -0,0 +1,270 @@
+require 'snmp/varbind'
+require 'test/unit'
+
+class TestVarBind < Test::Unit::TestCase
+    
+    include SNMP
+    
+    def test_varbind_encode
+        v = VarBind.new([1,3,6,1], OctetString.new("test"))
+        assert_equal("0\v\006\003+\006\001\004\004test", v.encode)
+        assert_not_nil(v.asn1_type)
+        assert_equal("[name=1.3.6.1, value=test (OCTET STRING)]", v.to_s)
+    end
+    
+    def test_varbind_decode
+        varbind, remainder = VarBind.decode("0\f\006\010+\006\001\002\001\001\001\000\005\000")
+        assert_equal(Null, varbind.value)
+        assert_equal("", remainder)
+
+        varbind, remainder = VarBind.decode("0\f\006\010+\006\001\002\001\001\001\000\005\0000\f\006\010+\006\001\002\001\001\002\000\005\000")
+        assert_equal(Null, varbind.value)
+        assert_equal("0\f\006\010+\006\001\002\001\001\002\000\005\000", remainder)
+    end
+
+    def test_varbind_list_create
+        list = VarBindList.new
+        assert_equal(0, list.length)
+        
+        check_varbind_list_create(VarBindList.new(["1.2.3.4.5"]))
+        check_varbind_list_create(VarBindList.new([ObjectId.new("1.2.3.4.5")]))
+        check_varbind_list_create(VarBindList.new([VarBind.new("1.2.3.4.5", Null)]))
+        
+        check_varbind_list_create(VarBindList.new(
+                ["1.2.3.4.5", "1.2.3.4.6"]), 2)
+
+        check_varbind_list_create(VarBindList.new(
+                [ObjectId.new("1.2.3.4.5"),
+                ObjectId.new("1.2.3.4.6")]
+            ), 2)
+        
+        check_varbind_list_create(VarBindList.new(
+                [VarBind.new("1.2.3.4.5", Null),
+                 VarBind.new("1.2.3.4.6", Integer.new(123)),
+                 ObjectId.new("1.2.3.4.7")]
+            ), 3)
+            
+        list = VarBindList.new([VarBind.new("1.3.6.2", Integer.new(1))])
+        assert_equal(1, list.length)
+        assert_equal("1.3.6.2", list.first.name.to_s)
+        assert_equal(1, list.first.value.to_i)
+    end
+
+    def check_varbind_list_create(list, n=1)
+        assert_equal(n, list.length)
+        assert_equal("1.2.3.4.5", list.first.name.to_s)
+        assert_equal(Null, list.first.value)
+    end
+    
+    def test_varbind_list_encode
+        list = VarBindList.new
+        assert_equal("0\000", list.encode)
+        assert_not_nil(list.asn1_type)
+        
+        list << VarBind.new([1,3,6,1], OctetString.new("test"))
+        assert_equal("0\r0\v\006\003+\006\001\004\004test", list.encode)
+
+        list << VarBind.new([1,3,6,1], OctetString.new("blah"))
+        assert_equal("0\0320\v\006\003+\006\001\004\004test0\v\006\003+\006\001\004\004blah", list.encode)
+    end
+
+    def test_varbind_list_decode
+        list, remainder = VarBindList.decode("0\r0\v\006\003+\006\001\004\004test")
+        assert_equal(1, list.length)
+        assert_equal("", remainder)
+        
+        list, remainder = VarBindList.decode("0\0320\v\006\003+\006\001\004\004test0\v\006\003+\006\001\004\004blah")
+        assert_equal(2, list.length)
+        assert_equal("", remainder)
+
+        list, remainder = VarBindList.decode("0\000")
+        assert_equal(0, list.length)
+        assert_equal("", remainder)
+    end
+    
+    def test_octet_string
+        string = OctetString.new("test")
+        assert_equal("test", string.to_s)
+        assert_equal("\004\004test", string.encode)
+        assert_not_nil(string.asn1_type)
+    end
+    
+    def test_octet_string_equals
+        s1 = OctetString.new("test")
+        s2 = "test"
+        s3 = OctetString.new("test")
+        assert_equal(s1, s2)
+        assert(s1 == s2)
+        assert_not_same(s1, s3)
+        assert_equal(s1, s3)
+    end
+    
+    def test_object_id
+        id = ObjectId.new([1,3,6,1])
+        assert_equal("1.3.6.1", id.to_s)
+        assert_equal("\006\003+\006\001", id.encode)
+        assert_not_nil(id.asn1_type)
+        assert_equal("1.3.6.1", id.to_varbind.name.to_s)
+        
+        assert_raise(ArgumentError) {
+            ObjectId.new("xyzzy")
+        }
+    end
+    
+    def test_object_id_create
+        assert_equal("1.3.6.1", ObjectId.new("1.3.6.1").to_s)
+        assert_equal("1.3.6.1", ObjectId.new([1,3,6,1]).to_s)
+        assert_equal("1.3.6.1", ObjectId.new(ObjectId.new("1.3.6.1")).to_s)
+    end
+    
+    def test_object_id_equals
+        id1 = ObjectId.new("1.3.3.4")
+        id2 = ObjectId.new([1,3,3,4])
+        assert_not_same(id1, id2)
+        assert(id1 == id2)
+        assert_equal(id1, id2)
+    end
+    
+    def test_object_id_comparable
+        id1 = ObjectId.new("1.3.3.4")
+        id2 = ObjectId.new("1.3.3.4.1")
+        id3 = ObjectId.new("1.3.3.4.5")
+        id4 = ObjectId.new("1.3.3.5")
+        assert(id1 < id2)
+        assert(id2 > id1)
+        assert(id2 < id3)
+        assert(id3 > id2)
+        assert(id3 < id4)
+        assert(id4 > id3)
+    end
+    
+    def test_object_id_subtree
+        id1 = ObjectId.new("1.3.3.4")
+        id2 = ObjectId.new("1.3.3.4.1")
+        id3 = ObjectId.new("1.3.3.4.5")
+        id4 = ObjectId.new("1.3.3.5")
+        assert(id2.subtree_of?(id1))
+        assert(id3.subtree_of?(id1))
+        assert(!id3.subtree_of?(id2))
+        assert(!id1.subtree_of?(id2))
+        assert(!id4.subtree_of?(id1))
+        assert(!id4.subtree_of?(id3))
+        assert(id1.subtree_of?("1.3.3.4"))
+        assert(!id4.subtree_of?("1.3.3.4"))
+    end
+    
+    def test_object_name_from_string
+        id = ObjectName.new("1.3.4.5.6")
+        assert_equal("1.3.4.5.6", id.to_s)
+        assert_equal("\006\004+\004\005\006", id.encode)
+    end
+    
+    def test_integer_create
+        i = Integer.new(12345)
+        assert_equal("12345", i.to_s)
+        assert_equal(12345, i.to_i)
+        assert_equal("\002\00209", i.encode)
+        assert_not_nil(i.asn1_type)
+    end
+    
+    def test_integer_decode
+        i = Integer.decode("09")
+        assert_equal(12345, i.to_i)
+    end
+    
+    def test_integer_equal
+        i1 = Integer.new(12345)
+        i2 = Integer.new(12345)
+        i3 = 12345.2
+        i4 = 12345
+        assert_not_same(i1, i2)
+        assert_equal(i1, i2)
+        assert_equal(i4, i1)
+        assert_equal(i1, i4)
+        assert_equal(i1, i3)
+    end
+    
+    def test_integer_comparable
+        i1 = Integer.new(12345)
+        i2 = Integer.new(54321.0)
+        assert(i1 < i2)
+        assert(i2 > i1)
+        assert(123 < i1)
+        assert(123.0 < i1)
+        assert(i2 > 54000)
+    end
+    
+    def test_ip_address_from_string
+        ip = IpAddress.new("10.0.255.1")
+        assert_equal("10.0.255.1", ip.to_s)
+        assert_raise(InvalidIpAddress) { IpAddress.new("1233.2.3.4") }
+        assert_raise(InvalidIpAddress) { IpAddress.new("1.2.3.-1") }
+        assert_raise(InvalidIpAddress) { IpAddress.new("1.2.3") }
+    end
+    
+    def test_ip_address_create
+        ip = IpAddress.new("\001\002\003\004")
+        assert_equal("1.2.3.4", ip.to_s)
+        assert_equal("\001\002\003\004", ip.to_str)
+        assert_equal("@\004\001\002\003\004", ip.encode)
+        assert_not_nil(ip.asn1_type)
+    end
+    
+    def test_ip_address_decode
+        ip = IpAddress.decode("\001\002\003\004")
+        assert_equal("1.2.3.4", ip.to_s)
+    end
+
+    def test_ip_address_equals
+        ip1 = IpAddress.new("1.2.3.4")
+        ip2 = IpAddress.new("1.2.3.4")
+        ip3 = IpAddress.new("10.2.3.4")
+        assert(ip1 == ip2)
+        assert(ip1.eql?(ip2))
+        assert(!ip1.equal?(ip2))
+        assert(ip1 != ip3)
+        assert(ip1.hash == ip2.hash)
+        assert(ip1.hash != ip3.hash)
+        assert(!ip1.eql?(12))
+    end
+        
+    def test_counter32_create
+        i = Counter32.new(12345)
+        assert_equal("12345", i.to_s)
+        assert_equal(12345, i.to_i)
+        assert_equal("\x41\00209", i.encode)
+        assert_not_nil(i.asn1_type)
+    end
+    
+    def test_counter32_decode
+        i = Counter32.decode("09")
+        assert_equal(12345, i.to_i)
+    end
+    
+    def test_counter64
+        i = Counter64.new(18446744073709551615)
+        assert_equal(18446744073709551615, i.to_i)
+        assert_equal("18446744073709551615", i.to_s)
+        assert_equal("F\t\000\377\377\377\377\377\377\377\377", i.encode)
+        assert_equal(i, Counter64.decode("\000\377\377\377\377\377\377\377\377"))
+        assert_not_nil(i.asn1_type)
+    end
+    
+    def test_opaque
+        q = Opaque.new("test")
+        assert_equal("D\004test", q.encode)
+        assert_equal("test", Opaque.decode("test"))
+        assert_equal("test", q.to_s)
+        assert_not_nil(q.asn1_type)
+    end
+    
+    def test_exception_methods
+        exception_types = [NoSuchObject, NoSuchInstance, EndOfMibView]
+        exception_types.each do |type|
+            assert(type.respond_to?(:decode))
+            assert(type.respond_to?(:encode))
+            assert_equal(type.asn1_type, type.to_s)
+        end
+    end
+    
+end