cisco_acl_intp 0.0.3 → 0.0.4

data/spec/cisco_acl_intp/{ace_proto_spec.rb → acespec_proto_spec.rb}

@@ -2,7 +2,7 @@
 require 'spec_helper'
 
 def get_port_table(data)
-  data.split(/\n/).reduce({}) do |tbl, line|
+  data.split(/\n/).each_with_object({}) do |line, tbl|
     md = line.match(/^\s*([\w\d\-]+)\s+.+[\s\(](\d+)\)$/)
     tbl[md[1]] = md[2] if md
     tbl
@@ -30,24 +30,24 @@ describe AceUdpProtoSpec do
   describe '#name_to_numer, #to_i' do
     it 'should be "111" by converting proto name "sunrpc"' do
       aups = AceUdpProtoSpec.new('sunrpc')
-      aups.number.should eq 111
-      aups.to_i.should eq 111
+      expect(aups.number).to eq 111
+      expect(aups.to_i).to eq 111
     end
 
     it 'should be error by converting unknown proto name "hoge"' do
-      lambda do
+      expect do
         AceUdpProtoSpec.new('hoge')
-      end.should raise_error(AclArgumentError)
+      end.to raise_error(AclArgumentError)
     end
   end
 
   describe 'class#valid_name?' do
     it 'should be true when valid udp port name' do
-      AceUdpProtoSpec.valid_name?('snmp').should be_true
+      expect(AceUdpProtoSpec.valid_name?('snmp')).to be_truthy
     end
 
     it 'should be false when invalid udp port name' do
-      AceUdpProtoSpec.valid_name?('daytime').should be_false
+      expect(AceUdpProtoSpec.valid_name?('daytime')).to be_falsey
     end
   end
 
@@ -86,26 +86,26 @@ EOL
 
     it 'should be number string when it not match IOS acl literal' do
       aups = AceUdpProtoSpec.new(3_333)
-      aups.to_s.should be_aclstr('3333')
+      expect(aups.to_s).to be_aclstr('3333')
     end
 
     it 'should be error when out of range port number' do
-      lambda do
+      expect do
         AceUdpProtoSpec.new(65_536)
-      end.should raise_error(AclArgumentError)
+      end.to raise_error(AclArgumentError)
 
-      lambda do
+      expect do
         AceUdpProtoSpec.new(-1)
-      end.should raise_error(AclArgumentError)
+      end.to raise_error(AclArgumentError)
     end
 
     it 'should be error when not specified name/number' do
-      lambda do
+      expect do
         AceUdpProtoSpec.new
-      end.should raise_error(AclArgumentError)
-      lambda do
+      end.to raise_error(AclArgumentError)
+      expect do
         AceUdpProtoSpec.new('')
-      end.should raise_error(AclArgumentError)
+      end.to raise_error(AclArgumentError)
     end
   end
 end
@@ -114,24 +114,24 @@ describe AceTcpProtoSpec do
   describe '#name_to_numer, #to_i' do
     it 'should be "49" by converting proto name "tacacs"' do
       atps = AceTcpProtoSpec.new('tacacs')
-      atps.number.should eq 49
-      atps.to_i.should eq 49
+      expect(atps.number).to eq 49
+      expect(atps.to_i).to eq 49
     end
 
     it 'should be error by converting unknown proto name "fuga"' do
-      lambda do
+      expect do
         AceTcpProtoSpec.new('fuga')
-      end.should raise_error(AclArgumentError)
+      end.to raise_error(AclArgumentError)
     end
   end
 
   describe 'class#valid_name?' do
     it 'should be true when valid tcp port name' do
-      AceTcpProtoSpec.valid_name?('daytime').should be_true
+      expect(AceTcpProtoSpec.valid_name?('daytime')).to be_truthy
     end
 
     it 'should be false when invalid tcp port name' do
-      AceTcpProtoSpec.valid_name?('snmp').should be_false
+      expect(AceTcpProtoSpec.valid_name?('snmp')).to be_falsey
     end
   end
 
@@ -176,26 +176,26 @@ EOL
 
     it 'should be number string when it not match IOS acl literal' do
       aups = AceTcpProtoSpec.new(6_633)
-      aups.to_s.should be_aclstr('6633')
+      expect(aups.to_s).to be_aclstr('6633')
     end
 
     it 'should be error when not specified name/number' do
-      lambda do
+      expect do
         AceTcpProtoSpec.new
-      end.should raise_error(AclArgumentError)
-      lambda do
+      end.to raise_error(AclArgumentError)
+      expect do
         AceTcpProtoSpec.new('')
-      end.should raise_error(AclArgumentError)
+      end.to raise_error(AclArgumentError)
     end
 
     it 'should be error when out of range port number' do
-      lambda do
+      expect do
         AceTcpProtoSpec.new(65_536)
-      end.should raise_error(AclArgumentError)
+      end.to raise_error(AclArgumentError)
 
-      lambda do
+      expect do
         AceTcpProtoSpec.new(-1)
-      end.should raise_error(AclArgumentError)
+      end.to raise_error(AclArgumentError)
     end
   end
 end
@@ -204,24 +204,24 @@ describe AceIpProtoSpec do
   describe '#name_to_numer' do
     it 'should be "88" by converting proto name "eigrp"' do
       aips = AceIpProtoSpec.new('eigrp')
-      aips.number.should eq 88
-      aips.to_i.should eq 88
+      expect(aips.number).to eq 88
+      expect(aips.to_i).to eq 88
     end
 
     it 'should be error by converting unknown proto name "foo"' do
-      lambda do
+      expect do
         AceIpProtoSpec.new('foo')
-      end.should raise_error(AclArgumentError)
+      end.to raise_error(AclArgumentError)
     end
   end
 
   describe 'class#valid_name?' do
     it 'should be true when valid tcp port name' do
-      AceIpProtoSpec.valid_name?('ospf').should be_true
+      expect(AceIpProtoSpec.valid_name?('ospf')).to be_truthy
     end
 
     it 'should be false when invalid tcp port name' do
-      AceIpProtoSpec.valid_name?('daytime').should be_false
+      expect(AceIpProtoSpec.valid_name?('daytime')).to be_falsey
     end
   end
 
@@ -237,30 +237,30 @@ describe AceIpProtoSpec do
     end
 
     it 'should be true, ip includes tcp/udp' do
-      @p_ip.contains?(@p_tcp).should be_true
-      @p_ip.contains?(@p_udp).should be_true
-      @p_ip.contains?(@p_ip2).should be_true
+      expect(@p_ip.contains?(@p_tcp)).to be_truthy
+      expect(@p_ip.contains?(@p_udp)).to be_truthy
+      expect(@p_ip.contains?(@p_ip2)).to be_truthy
     end
 
     it 'should be false, ip not includes esp' do
-      @p_ip.contains?(@p_esp).should be_false
-      @p_esp.contains?(@p_ip).should be_false
-      @p_esp.contains?(@p_tcp).should be_false
-      @p_esp.contains?(@p_udp).should be_false
+      expect(@p_ip.contains?(@p_esp)).to be_falsey
+      expect(@p_esp.contains?(@p_ip)).to be_falsey
+      expect(@p_esp.contains?(@p_tcp)).to be_falsey
+      expect(@p_esp.contains?(@p_udp)).to be_falsey
     end
 
     it 'should be true, tcp/udp includes tcp/udp' do
-      @p_tcp.contains?(@p_tcp2).should be_true
-      @p_udp.contains?(@p_udp2).should be_true
+      expect(@p_tcp.contains?(@p_tcp2)).to be_truthy
+      expect(@p_udp.contains?(@p_udp2)).to be_truthy
     end
 
     it 'should be false, tcp/udp not includes ip/udp/tcp' do
-      @p_tcp.contains?(@p_ip).should be_false
-      @p_tcp.contains?(@p_udp).should be_false
-      @p_tcp.contains?(@p_esp).should be_false
-      @p_udp.contains?(@p_ip).should be_false
-      @p_udp.contains?(@p_tcp).should be_false
-      @p_udp.contains?(@p_esp).should be_false
+      expect(@p_tcp.contains?(@p_ip)).to be_falsey
+      expect(@p_tcp.contains?(@p_udp)).to be_falsey
+      expect(@p_tcp.contains?(@p_esp)).to be_falsey
+      expect(@p_udp.contains?(@p_ip)).to be_falsey
+      expect(@p_udp.contains?(@p_tcp)).to be_falsey
+      expect(@p_udp.contains?(@p_esp)).to be_falsey
     end
   end
 
@@ -285,26 +285,26 @@ EOL
 
     it 'should be number string when it not match IOS acl literal' do
       aups = AceIpProtoSpec.new(255)
-      aups.to_s.should be_aclstr('255')
+      expect(aups.to_s).to be_aclstr('255')
     end
 
     it 'should be error when out of range port number' do
-      lambda do
+      expect do
         AceIpProtoSpec.new(256)
-      end.should raise_error(AclArgumentError)
+      end.to raise_error(AclArgumentError)
 
-      lambda do
+      expect do
         AceIpProtoSpec.new(-1)
-      end.should raise_error(AclArgumentError)
+      end.to raise_error(AclArgumentError)
     end
 
     it 'should be error when not specified name/number' do
-      lambda do
+      expect do
         AceIpProtoSpec.new
-      end.should raise_error(AclArgumentError)
-      lambda do
+      end.to raise_error(AclArgumentError)
+      expect do
         AceIpProtoSpec.new('')
-      end.should raise_error(AclArgumentError)
+      end.to raise_error(AclArgumentError)
     end
   end
 end

data/spec/cisco_acl_intp/{ace_srcdst_spec.rb → acespec_srcdst_spec.rb}

@@ -23,15 +23,15 @@ describe AceSrcDstSpec do
     end
 
     it 'should be true when same ip/netmask/wildcard' do
-      (@sds1 == @sds2).should be_true
+      expect(@sds1 == @sds2).to be_truthy
     end
 
     it 'should be false when different operator' do
-      (@sds1 == @sds3).should be_false
+      expect(@sds1 == @sds3).to be_falsey
     end
 
     it 'should be false when different ip' do
-      (@sds1 == @sds4).should be_false
+      expect(@sds1 == @sds4).to be_falsey
     end
   end
 
@@ -42,7 +42,7 @@ describe AceSrcDstSpec do
           ipaddr: '192.168.3.3',
           wildcard: '0.0.0.127'
         )
-        sds.to_s.should be_aclstr('192.168.3.0 0.0.0.127')
+        expect(sds.to_s).to be_aclstr('192.168.3.0 0.0.0.127')
       end
 
       it 'should be "192.168.3.0 eq www" with L4 port' do
@@ -52,17 +52,17 @@ describe AceSrcDstSpec do
           operator: 'eq',
           port: AceTcpProtoSpec.new(80)
         )
-        sds.to_s.should be_aclstr('192.168.3.0 0.0.0.127 eq www')
+        expect(sds.to_s).to be_aclstr('192.168.3.0 0.0.0.127 eq www')
       end
     end
 
     context 'Argument error case' do
       it 'should be raise exception when :ipaddr not specified' do
-        lambda do
+        expect do
           AceSrcDstSpec.new(
             wildcard: '0.0.0.127'
           )
-        end.should raise_error(AclArgumentError)
+        end.to raise_error(AclArgumentError)
       end
       ## TBD, error handling must be written in detail
     end
@@ -91,28 +91,48 @@ describe AceSrcDstSpec do
       end
 
       it 'should be true when match ip and ANY port' do
-        @sds0.contains?(_srcdst(@ip_match, :eq, @p1_match)).should be_true
-        @sds0.contains?(_srcdst(@ip_match, :eq, @p1_unmatch)).should be_true
+        expect(
+          @sds0.contains?(_srcdst(@ip_match, :eq, @p1_match))
+        ).to be_truthy
+        expect(
+          @sds0.contains?(_srcdst(@ip_match, :eq, @p1_unmatch))
+        ).to be_truthy
       end
 
       it 'should be false when unmatch ip and ANY port' do
-        @sds0.contains?(_srcdst(@ip_unmatch, :eq, @p1_match)).should be_false
-        @sds0.contains?(_srcdst(@ip_unmatch, :eq, @p1_unmatch)).should be_false
+        expect(
+          @sds0.contains?(_srcdst(@ip_unmatch, :eq, @p1_match))
+        ).to be_falsey
+        expect(
+          @sds0.contains?(_srcdst(@ip_unmatch, :eq, @p1_unmatch))
+        ).to be_falsey
       end
 
       it 'should be true when match ip and contained port set' do
-        @sds1.contains?(_srcdst(@ip_match, :eq, @p1_lower)).should be_true
-        @sds1.contains?(_srcdst(@ip_match, :lt, @p1_match)).should be_true
+        expect(
+          @sds1.contains?(_srcdst(@ip_match, :eq, @p1_lower))
+        ).to be_truthy
+        expect(
+          @sds1.contains?(_srcdst(@ip_match, :lt, @p1_match))
+        ).to be_truthy
       end
 
       it 'should be false when unmatch ip and contained port set' do
-        @sds1.contains?(_srcdst(@ip_unmatch, :eq, @p1_lower)).should be_false
-        @sds1.contains?(_srcdst(@ip_unmatch, :lt, @p1_match)).should be_false
+        expect(
+          @sds1.contains?(_srcdst(@ip_unmatch, :eq, @p1_lower))
+        ).to be_falsey
+        expect(
+          @sds1.contains?(_srcdst(@ip_unmatch, :lt, @p1_match))
+        ).to be_falsey
       end
 
       it 'should be false when match ip and not-contained port set' do
-        @sds1.contains?(_srcdst(@ip_match, :eq, @p1_match)).should be_false
-        @sds1.contains?(_srcdst(@ip_match, :lt, @p1_higher)).should be_false
+        expect(
+          @sds1.contains?(_srcdst(@ip_match, :eq, @p1_match))
+        ).to be_falsey
+        expect(
+          @sds1.contains?(_srcdst(@ip_match, :lt, @p1_higher))
+        ).to be_falsey
       end
     end
 
@@ -133,41 +153,49 @@ describe AceSrcDstSpec do
       end
 
       it 'should be true when contained (length)' do
-        @sds0.contains?(_srcdst(@ip_contained1, :eq, @p1_match)).should be_true
-        @sds1.contains?(_srcdst(@ip_contained1, :eq, @p1_match)).should be_true
+        expect(
+          @sds0.contains?(_srcdst(@ip_contained1, :eq, @p1_match))
+        ).to be_truthy
+        expect(
+          @sds1.contains?(_srcdst(@ip_contained1, :eq, @p1_match))
+        ).to be_truthy
       end
 
       it 'should be true when contained (bitmask)' do
-        @sds0.contains?(_srcdst(@ip_contained2, :eq, @p1_match)).should be_true
-        @sds1.contains?(_srcdst(@ip_contained2, :eq, @p1_match)).should be_true
+        expect(
+          @sds0.contains?(_srcdst(@ip_contained2, :eq, @p1_match))
+        ).to be_truthy
+        expect(
+          @sds1.contains?(_srcdst(@ip_contained2, :eq, @p1_match))
+        ).to be_truthy
       end
 
       it 'should be false when not contained (length)' do
-        @sds0.contains?(
-          _srcdst(@ip_not_contained1, :eq, @p1_match)
-        ).should be_false
-        @sds1.contains?(
-          _srcdst(@ip_not_contained1, :eq, @p1_match)
-        ).should be_false
+        expect(
+          @sds0.contains?(_srcdst(@ip_not_contained1, :eq, @p1_match))
+        ).to be_falsey
+        expect(
+          @sds1.contains?(_srcdst(@ip_not_contained1, :eq, @p1_match))
+        ).to be_falsey
       end
 
       it 'should be false when not contained (bitmask)' do
-        @sds0.contains?(
-          _srcdst(@ip_not_contained2, :eq, @p1_match)
-        ).should be_false
-        @sds1.contains?(
-          _srcdst(@ip_not_contained2, :eq, @p1_match)
-        ).should be_false
+        expect(
+          @sds0.contains?(_srcdst(@ip_not_contained2, :eq, @p1_match))
+        ).to be_falsey
+        expect(
+          @sds1.contains?(_srcdst(@ip_not_contained2, :eq, @p1_match))
+        ).to be_falsey
       end
 
       it 'should be raised error when invalid subnet notation' do
-        lambda do
+        expect do
           @sds0.contains?(_srcdst(@ip_error1, :eq, @p1_match))
-        end.should raise_error(NetAddr::ValidationError)
+        end.to raise_error(NetAddr::ValidationError)
 
-        lambda do
+        expect do
           @sds1.contains?(_srcdst(@ip_error1, :eq, @p1_match))
-        end.should raise_error(NetAddr::ValidationError)
+        end.to raise_error(NetAddr::ValidationError)
 
         # lambda do
         # @sds0.contains?(_srcdst(@ip_error2, :eq, @p1_match)).should be_false
@@ -198,16 +226,24 @@ describe AceSrcDstSpec do
       end
 
       it 'should be true, with match ip in range port' do
-        @sds.contains?(_srcdst(@ip_match, :eq, @p_in)).should be_true
+        expect(
+          @sds.contains?(_srcdst(@ip_match, :eq, @p_in))
+        ).to be_truthy
       end
 
       it 'should be false, with match ip and out of range port' do
-        @sds.contains?(_srcdst(@ip_match, :eq, @p_out_lower)).should be_false
-        @sds.contains?(_srcdst(@ip_match, :eq, @p_out_higher)).should be_false
+        expect(
+          @sds.contains?(_srcdst(@ip_match, :eq, @p_out_lower))
+        ).to be_falsey
+        expect(
+          @sds.contains?(_srcdst(@ip_match, :eq, @p_out_higher))
+        ).to be_falsey
       end
 
       it 'should be false, with unmatch ip match in range port' do
-        @sds.contains?(_srcdst(@ip_unmatch, :eq, @p_in)).should be_false
+        expect(
+          @sds.contains?(_srcdst(@ip_unmatch, :eq, @p_in))
+        ).to be_falsey
       end
     end
 
@@ -248,32 +284,55 @@ describe AceSrcDstSpec do
       end
 
       it 'should be true, for any ip' do
-        @sds1.contains?(_srcdst(@ip_match, :eq, @p_match)).should be_true
-        @sds1.contains?(_srcdst(@ip_unmatch, :eq, @p_match)).should be_true
+        expect(
+          @sds1.contains?(_srcdst(@ip_match, :eq, @p_match))
+        ).to be_truthy
+        expect(
+          @sds1.contains?(_srcdst(@ip_unmatch, :eq, @p_match))
+        ).to be_truthy
       end
 
       it 'should be false, for any ip with unmatch port' do
-        @sds1.contains?(_srcdst(@ip_match, :eq, @p_unmatch)).should be_false
-        @sds1.contains?(_srcdst(@ip_unmatch, :eq, @p_unmatch)).should be_false
+        expect(
+          @sds1.contains?(_srcdst(@ip_match, :eq, @p_unmatch))
+        ).to be_falsey
+        expect(
+          @sds1.contains?(_srcdst(@ip_unmatch, :eq, @p_unmatch))
+        ).to be_falsey
       end
 
       it 'should be true, for any port' do
-        @sds2.contains?(_srcdst(@ip_match, :eq, @p_match)).should be_true
-        @sds2.contains?(_srcdst(@ip_match, :eq, @p_unmatch)).should be_true
+        expect(
+          @sds2.contains?(_srcdst(@ip_match, :eq, @p_match))
+        ).to be_truthy
+        expect(
+          @sds2.contains?(_srcdst(@ip_match, :eq, @p_unmatch))
+        ).to be_truthy
       end
 
       it 'should be false, for any port with unmatch ip' do
-        @sds2.contains?(_srcdst(@ip_unmatch, :eq, @p_match)).should be_false
-        @sds2.contains?(_srcdst(@ip_unmatch, :eq, @p_unmatch)).should be_false
+        expect(
+          @sds2.contains?(_srcdst(@ip_unmatch, :eq, @p_match))
+        ).to be_falsey
+        expect(
+          @sds2.contains?(_srcdst(@ip_unmatch, :eq, @p_unmatch))
+        ).to be_falsey
       end
 
       it 'should be true, for any ip and any port' do
-        @sds3.contains?(_srcdst(@ip_match, :eq, @p_match)).should be_true
-        @sds3.contains?(_srcdst(@ip_match, :eq, @p_unmatch)).should be_true
-        @sds3.contains?(_srcdst(@ip_unmatch, :eq, @p_match)).should be_true
-        @sds3.contains?(_srcdst(@ip_unmatch, :eq, @p_unmatch)).should be_true
+        expect(
+          @sds3.contains?(_srcdst(@ip_match, :eq, @p_match))
+        ).to be_truthy
+        expect(
+          @sds3.contains?(_srcdst(@ip_match, :eq, @p_unmatch))
+        ).to be_truthy
+        expect(
+          @sds3.contains?(_srcdst(@ip_unmatch, :eq, @p_match))
+        ).to be_truthy
+        expect(
+          @sds3.contains?(_srcdst(@ip_unmatch, :eq, @p_unmatch))
+        ).to be_truthy
       end
     end
-
   end # describe contains?
 end # describe AceSrcDstSpec