ipaddress 0.8.0 → 0.8.2

data/lib/ipaddress/prefix.rb

@@ -214,8 +214,8 @@ module IPAddress
     #     #=> 64
     #
     def initialize(num=128)
-      unless (1..128).include? num.to_i
-        raise ArgumentError, "Prefix must be in range 1..128, got: #{num}"
+      unless (0..128).include? num.to_i
+        raise ArgumentError, "Prefix must be in range 0..128, got: #{num}"
       end
       super(num.to_i)
     end

data/lib/ipaddress/version.rb

@@ -0,0 +1,3 @@
+module Ipaddress
+  VERSION = "0.8.2"
+end

data/test/ipaddress/ipv4_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
  
-class IPv4Test < Test::Unit::TestCase
+class IPv4Test < Minitest::Test
 
   def setup
     @klass = IPAddress::IPv4
@@ -26,7 +26,8 @@ class IPv4Test < Test::Unit::TestCase
       "10.0.0.0/8"       => "255.0.0.0",
       "172.16.0.0/16"    => "255.255.0.0",
       "192.168.0.0/24"   => "255.255.255.0",
-      "192.168.100.4/30" => "255.255.255.252"}
+      "192.168.100.4/30" => "255.255.255.252",
+      "192.168.12.4/32"  => "255.255.255.255"}
 
     @decimal_values ={      
       "0.0.0.0/0"        => 0,
@@ -34,7 +35,13 @@ class IPv4Test < Test::Unit::TestCase
       "172.16.0.0/16"    => 2886729728,
       "192.168.0.0/24"   => 3232235520,
       "192.168.100.4/30" => 3232261124}
-    
+
+    @hex_values = {
+      "10.0.0.0"         => "0a000000",
+      "172.16.5.4"       => "ac100504",
+      "192.168.100.4"    => "c0a86404",
+    }
+
     @ip = @klass.new("172.16.10.1/24")
     @network = @klass.new("172.16.10.0/24")
     
@@ -42,13 +49,17 @@ class IPv4Test < Test::Unit::TestCase
       "10.0.0.0/8"       => "10.255.255.255/8",
       "172.16.0.0/16"    => "172.16.255.255/16",
       "192.168.0.0/24"   => "192.168.0.255/24",
-      "192.168.100.4/30" => "192.168.100.7/30"}
+      "192.168.100.4/30" => "192.168.100.7/30",
+      "192.168.12.3/31"  => "255.255.255.255/31",
+      "10.0.0.1/32"      => "10.0.0.1/32"}
     
     @networks = {
       "10.5.4.3/8"       => "10.0.0.0/8",
       "172.16.5.4/16"    => "172.16.0.0/16",
       "192.168.4.3/24"   => "192.168.4.0/24",
-      "192.168.100.5/30" => "192.168.100.4/30"}
+      "192.168.100.5/30" => "192.168.100.4/30",
+      "192.168.1.3/31"   => "192.168.1.2/31",
+      "192.168.2.5/32"   => "192.168.2.5/32"}
 
     @class_a = @klass.new("10.0.0.1/8")
     @class_b = @klass.new("172.16.0.1/16")
@@ -58,6 +69,11 @@ class IPv4Test < Test::Unit::TestCase
       "10.1.1.1"  => 8,
       "150.1.1.1" => 16,
       "200.1.1.1" => 24 }
+
+    @in_range = {
+      "10.32.0.1" => ["10.32.0.253", 253],
+      "192.0.0.0" => ["192.1.255.255", 131072]
+    }
     
   end
 
@@ -67,25 +83,19 @@ class IPv4Test < Test::Unit::TestCase
       assert_instance_of @klass, ip
     end
     assert_instance_of IPAddress::Prefix32, @ip.prefix
-    assert_raise (ArgumentError) do
+    assert_raises (ArgumentError) do
       @klass.new 
     end
-    assert_nothing_raised do
-      @klass.new "10.0.0.0/8"
-    end
   end
 
   def test_initialize_format_error
     @invalid_ipv4.each do |i|
-      assert_raise(ArgumentError) {@klass.new(i)}
+      assert_raises(ArgumentError) {@klass.new(i)}
     end
-    assert_raise (ArgumentError) {@klass.new("10.0.0.0/asd")}
+    assert_raises (ArgumentError) {@klass.new("10.0.0.0/asd")}
   end
 
   def test_initialize_without_prefix
-    assert_nothing_raised do
-      @klass.new("10.10.0.0")
-    end
     ip = @klass.new("10.10.0.0")
     assert_instance_of IPAddress::Prefix32, ip.prefix
     assert_equal 32, ip.prefix.to_i
@@ -105,11 +115,15 @@ class IPv4Test < Test::Unit::TestCase
   end
   
   def test_initialize_should_require_ip
-    assert_raise(ArgumentError) { @klass.new }
+    assert_raises(ArgumentError) { @klass.new }
   end
 
   def test_method_data
-    assert_equal "\254\020\n\001", @ip.data
+    if RUBY_VERSION < "2.0"
+      assert_equal "\254\020\n\001", @ip.data
+    else
+      assert_equal "\xAC\x10\n\x01".b, @ip.data
+    end
   end
   
   def test_method_to_string
@@ -140,10 +154,22 @@ class IPv4Test < Test::Unit::TestCase
     end
   end
 
+  def test_method_to_hex
+    @hex_values.each do |addr,hex|
+      ip = @klass.new(addr)
+      assert_equal hex, ip.to_hex
+    end
+  end
+
   def test_method_network?
     assert_equal true, @network.network?
     assert_equal false, @ip.network?
   end
+  
+  def test_one_address_network
+    network = @klass.new("172.16.10.1/32")
+    assert_equal false, network.network?
+  end
 
   def test_method_broadcast
     @broadcast.each do |addr,bcast|
@@ -173,6 +199,12 @@ class IPv4Test < Test::Unit::TestCase
     ip = @klass.new("192.168.100.50/24")
     assert_instance_of @klass, ip.first
     assert_equal "192.168.100.1", ip.first.to_s
+    ip = @klass.new("192.168.100.50/32")
+    assert_instance_of @klass, ip.first
+    assert_equal "192.168.100.50", ip.first.to_s
+    ip = @klass.new("192.168.100.50/31")
+    assert_instance_of @klass, ip.first
+    assert_equal "192.168.100.50", ip.first.to_s
   end
 
   def test_method_last
@@ -182,6 +214,12 @@ class IPv4Test < Test::Unit::TestCase
     ip = @klass.new("192.168.100.50/24")
     assert_instance_of @klass, ip.last
     assert_equal  "192.168.100.254", ip.last.to_s
+    ip = @klass.new("192.168.100.50/32")
+    assert_instance_of @klass, ip.last
+    assert_equal  "192.168.100.50", ip.last.to_s
+    ip = @klass.new("192.168.100.50/31")
+    assert_instance_of @klass, ip.last
+    assert_equal  "192.168.100.51", ip.last.to_s
   end
   
   def test_method_each_host
@@ -378,8 +416,8 @@ class IPv4Test < Test::Unit::TestCase
   end
 
   def test_method_split
-    assert_raise(ArgumentError) {@ip.split(0)}
-    assert_raise(ArgumentError) {@ip.split(257)}
+    assert_raises(ArgumentError) {@ip.split(0)}
+    assert_raises(ArgumentError) {@ip.split(257)}
     
     assert_equal @ip.network, @ip.split(1).first
     
@@ -409,9 +447,8 @@ class IPv4Test < Test::Unit::TestCase
   end
 
   def test_method_subnet
-    assert_raise(ArgumentError) {@network.subnet(23)}
-    assert_raise(ArgumentError) {@network.subnet(33)}
-    assert_nothing_raised {@ip.subnet(30)}
+    assert_raises(ArgumentError) {@network.subnet(23)}
+    assert_raises(ArgumentError) {@network.subnet(33)}
     arr = ["172.16.10.0/26", "172.16.10.64/26", "172.16.10.128/26", 
            "172.16.10.192/26"]
     assert_equal arr, @network.subnet(26).map {|s| s.to_string}
@@ -422,7 +459,7 @@ class IPv4Test < Test::Unit::TestCase
   end
   
   def test_method_supernet
-    assert_raise(ArgumentError) {@ip.supernet(24)}     
+    assert_raises(ArgumentError) {@ip.supernet(24)}     
     assert_equal "0.0.0.0/0", @ip.supernet(0).to_string
     assert_equal "0.0.0.0/0", @ip.supernet(-2).to_string
     assert_equal "172.16.10.0/23", @ip.supernet(23).to_string
@@ -524,9 +561,40 @@ class IPv4Test < Test::Unit::TestCase
       assert_equal prefix, res.prefix
       assert_equal "#{ip}/#{prefix}", res.to_string
     end
-    assert_raise(ArgumentError){ @klass.parse_classful("192.168.256.257") }
+    assert_raises(ArgumentError){ @klass.parse_classful("192.168.256.257") }
   end
   
+  def test_network_split
+    @classful.each do |ip,net|
+      x = @klass.new("#{ip}/#{net}") 
+      assert_equal x.split(1).length, 1
+      assert_equal x.split(2).length, 2
+      assert_equal x.split(32).length, 32
+      assert_equal x.split(256).length, 256
+    end
+  end
+
+  def test_in_range
+    @in_range.each do |s,d|
+      ip = @klass.new(s)
+      assert_equal ip.to(d[0]).length, d[1]  
+    end
+  end
+
+  def test_octect_updates
+    ip = @klass.new("10.0.1.15/32")
+    ip[1] = 15
+    assert_equal "10.15.1.15/32", ip.to_string
+
+    ip = @klass.new("172.16.100.1")
+    ip[3] = 200
+    assert_equal "172.16.100.200/32", ip.to_string
+
+    ip = @klass.new("192.168.199.0/24")
+    ip[2] = 200
+    assert_equal "192.168.200.0/24", ip.to_string
+  end
+
 end # class IPv4Test
 
   

data/test/ipaddress/ipv6_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
  
-class IPv6Test < Test::Unit::TestCase
+class IPv6Test < Minitest::Test
   
   def setup
     @klass = IPAddress::IPv6
@@ -31,7 +31,9 @@ class IPv6Test < Test::Unit::TestCase
       "1080::8:800:200C:417A" => 21932261930451111902915077091070067066}
       
     @invalid_ipv6 = [":1:2:3:4:5:6:7",
-                     ":1:2:3:4:5:6:7"]
+                     ":1:2:3:4:5:6:7",
+                     "2002:516:2:200",
+                     "dd"]
 
     @networks = {
       "2001:db8:1:1:1:1:1:1/32" => "2001:db8::/32",
@@ -51,15 +53,12 @@ class IPv6Test < Test::Unit::TestCase
 
   def test_initialize
     assert_instance_of @klass, @ip
-    @valid_ipv6.keys.each do |ip|
-      assert_nothing_raised {@klass.new ip}
-    end
     @invalid_ipv6.each do |ip|
-      assert_raise(ArgumentError) {@klass.new ip}
+      assert_raises(ArgumentError) {@klass.new ip}
     end
     assert_equal 64, @ip.prefix
 
-    assert_raise(ArgumentError) {
+    assert_raises(ArgumentError) {
       @klass.new "::10.1.1.1"
     }
   end
@@ -180,7 +179,11 @@ class IPv6Test < Test::Unit::TestCase
   end
   
   def test_method_data
-    str = " \001\r\270\000\000\000\000\000\b\b\000 \fAz"
+    if RUBY_VERSION < "2.0"
+      str = " \001\r\270\000\000\000\000\000\b\b\000 \fAz"
+    else
+      str = " \x01\r\xB8\x00\x00\x00\x00\x00\b\b\x00 \fAz".b
+    end
     assert_equal str, @ip.data
   end
 
@@ -257,18 +260,18 @@ class IPv6Test < Test::Unit::TestCase
     compressed = "2001:db8:0:cd30::"
     expanded = "2001:0db8:0000:cd30:0000:0000:0000:0000"
     assert_equal expanded, @klass.expand(compressed)
-    assert_not_equal expanded, @klass.expand("2001:0db8:0:cd3")
-    assert_not_equal expanded, @klass.expand("2001:0db8::cd30")
-    assert_not_equal expanded, @klass.expand("2001:0db8::cd3")
+    refute_equal expanded, @klass.expand("2001:0db8:0::cd3")
+    refute_equal expanded, @klass.expand("2001:0db8::cd30")
+    refute_equal expanded, @klass.expand("2001:0db8::cd3")
   end
   
   def test_classmethod_compress
     compressed = "2001:db8:0:cd30::"
     expanded = "2001:0db8:0000:cd30:0000:0000:0000:0000"
     assert_equal compressed, @klass.compress(expanded)
-    assert_not_equal compressed, @klass.compress("2001:0db8:0:cd3")
-    assert_not_equal compressed, @klass.compress("2001:0db8::cd30")
-    assert_not_equal compressed, @klass.compress("2001:0db8::cd3")
+    refute_equal compressed, @klass.compress("2001:0db8:0::cd3")
+    refute_equal compressed, @klass.compress("2001:0db8::cd30")
+    refute_equal compressed, @klass.compress("2001:0db8::cd3")
   end
 
   def test_classmethod_parse_data
@@ -289,9 +292,15 @@ class IPv6Test < Test::Unit::TestCase
     assert_equal @ip.to_s, @klass.parse_hex(@hex,64).to_s
   end
 
+  def test_group_updates
+    ip = @klass.new("2001:db8::8:800:200c:417a/64")
+    ip[2] = '1234'
+    assert_equal "2001:db8:4d2:0:8:800:200c:417a/64", ip.to_string
+  end
+
 end # class IPv6Test
 
-class IPv6UnspecifiedTest < Test::Unit::TestCase
+class IPv6UnspecifiedTest < Minitest::Test
   
   def setup
     @klass = IPAddress::IPv6::Unspecified
@@ -304,7 +313,6 @@ class IPv6UnspecifiedTest < Test::Unit::TestCase
   end
 
   def test_initialize
-    assert_nothing_raised {@klass.new}
     assert_instance_of @klass, @ip
   end
 
@@ -325,7 +333,7 @@ class IPv6UnspecifiedTest < Test::Unit::TestCase
 end # class IPv6UnspecifiedTest
 
 
-class IPv6LoopbackTest < Test::Unit::TestCase
+class IPv6LoopbackTest < Minitest::Test
   
   def setup
     @klass = IPAddress::IPv6::Loopback
@@ -338,7 +346,6 @@ class IPv6LoopbackTest < Test::Unit::TestCase
   end
 
   def test_initialize
-    assert_nothing_raised {@klass.new}
     assert_instance_of @klass, @ip
   end
 
@@ -358,7 +365,7 @@ class IPv6LoopbackTest < Test::Unit::TestCase
   
 end # class IPv6LoopbackTest
 
-class IPv6MappedTest < Test::Unit::TestCase
+class IPv6MappedTest < Minitest::Test
   
   def setup
     @klass = IPAddress::IPv6::Mapped
@@ -384,14 +391,11 @@ class IPv6MappedTest < Test::Unit::TestCase
   end
 
   def test_initialize
-    assert_nothing_raised {@klass.new("::172.16.10.1")}
     assert_instance_of @klass, @ip
     @valid_mapped.each do |ip, u128|
-      assert_nothing_raised {@klass.new ip}
       assert_equal u128, @klass.new(ip).to_u128
     end
     @valid_mapped_ipv6.each do |ip, u128|
-      assert_nothing_raised {@klass.new ip}
       assert_equal u128, @klass.new(ip).to_u128
     end
   end
@@ -418,5 +422,5 @@ class IPv6MappedTest < Test::Unit::TestCase
   def test_mapped?
     assert_equal true, @ip.mapped?
   end
-  
+
 end # class IPv6MappedTest

data/test/ipaddress/mongoid_test.rb

@@ -0,0 +1,70 @@
+require 'test_helper'
+require 'ipaddress/mongoid'
+ 
+class MongoidTest < Minitest::Test
+
+  def setup
+    @valid_host4               = "172.16.10.1"
+    @valid_host6               = "2001:0db8:0000:0000:0008:0800:200c:417a"
+    @valid_host6_compressed    = IPAddress::IPv6.compress(@valid_host6)
+    @valid_network4            = "#{@valid_host4}/24"
+    @valid_network6            = "#{@valid_host6}/96"
+    @valid_network6_compressed = "#{@valid_host6_compressed}/96"
+    @host4                     = IPAddress.parse(@valid_host4)
+    @host6                     = IPAddress.parse(@valid_host6)
+    @network4                  = IPAddress.parse(@valid_network4)
+    @network6                  = IPAddress.parse(@valid_network6)
+    @invalid_values            = [nil, "", "invalid"]
+  end
+
+  def test_mongoize
+    # Instance method should be delegated to class method
+    assert_equal @host4.mongoize,    IPAddress.mongoize(@host4)
+    assert_equal @network4.mongoize, IPAddress.mongoize(@network4)
+
+    # Hosts addresses should be stored without prefix
+    assert_equal @valid_host4, IPAddress.mongoize(@host4)
+    assert_equal @valid_host6, IPAddress.mongoize(@host6)
+    assert_equal @valid_host4, IPAddress.mongoize("#{@host4}/32")
+    assert_equal @valid_host6, IPAddress.mongoize("#{@host6}/128")
+
+    # Network addresses should be stored with their prefix
+    assert_equal @valid_network4, IPAddress.mongoize(@network4)
+    assert_equal @valid_network6, IPAddress.mongoize(@network6)
+
+    # IPv6 addresses should always be stored uncompressed
+    assert_equal @valid_host6,    IPAddress.mongoize(@valid_host6_compressed)
+    assert_equal @valid_network6, IPAddress.mongoize(@valid_network6_compressed)
+
+    @invalid_values.each do |invalid_value|
+      # Invalid addresses should serialize to nil
+      assert_equal nil, IPAddress.mongoize(invalid_value)
+    end
+  end
+
+  def test_demongoize
+    # Valid stored values should be loaded with expected IPAddress type
+    assert_instance_of IPAddress::IPv4, IPAddress.demongoize(@valid_host4)
+    assert_instance_of IPAddress::IPv6, IPAddress.demongoize(@valid_host6)
+    assert_instance_of IPAddress::IPv4, IPAddress.demongoize(@valid_network4)
+    assert_instance_of IPAddress::IPv6, IPAddress.demongoize(@valid_network6)
+
+    # Valid stored values should be loaded as the original IPAddress object
+    assert_equal @host4,    IPAddress.demongoize(@valid_host4)
+    assert_equal @host6,    IPAddress.demongoize(@valid_host6)
+    assert_equal @network4, IPAddress.demongoize(@valid_network4)
+    assert_equal @network6, IPAddress.demongoize(@valid_network6)
+
+    @invalid_values.each do |invalid_value|
+      # Invalid stored value should be loaded as nil
+      assert_equal nil, IPAddress.demongoize(invalid_value)
+    end
+  end
+
+  def test_evolve
+    # evolve should delegate to mongoize
+    assert_equal IPAddress.mongoize(@valid_host4),    IPAddress.evolve(@valid_host4)
+    assert_equal IPAddress.mongoize(@valid_network4), IPAddress.evolve(@valid_network4)
+  end
+
+end