nayutaya-webhook-dispatcher 0.0.1 → 0.0.2

data/test/acl/entry_base_test.rb

@@ -0,0 +1,248 @@
+
+require File.dirname(__FILE__) + "/../test_helper"
+require "webhook-dispatcher/acl/entry_base"
+
+class EntryBaseTest < Test::Unit::TestCase
+  def setup
+    @klass = WebHookDispatcher::Acl::EntryBase
+  end
+
+  def test_initialize__all
+    assert_equal(
+      [nil, nil, nil],
+      @klass.new.to_a)
+    assert_equal(
+      [nil, nil, nil],
+      @klass.new(nil).to_a)
+    assert_equal(
+      [nil, nil, nil],
+      @klass.new(:all).to_a)
+    assert_equal(
+      [nil, nil, nil],
+      @klass.new({}).to_a)
+  end
+
+  def test_initialize__addr
+    assert_equal(
+      [nil, nil, nil],
+      @klass.new(:addr => :all).to_a)
+    assert_equal(
+      [IPAddr.new("127.0.0.1/32"), nil, nil],
+      @klass.new(:addr => "127.0.0.1").to_a)
+    assert_equal(
+      [IPAddr.new("127.0.0.0/8"), nil, nil],
+      @klass.new(:addr => IPAddr.new("127.0.0.0/8")).to_a)
+
+    assert_raise(ArgumentError) {
+      @klass.new(:addr => :invalid)
+    }
+  end
+
+  def test_initialize__name
+    assert_equal(
+      [nil, nil, nil],
+      @klass.new(:name => :all).to_a)
+    assert_equal(
+      [nil, "google.co.jp", nil],
+      @klass.new(:name => "GOOGLE.CO.JP").to_a)
+    assert_equal(
+      [nil, /google\.co\.jp/, nil],
+      @klass.new(:name => /google\.co\.jp/).to_a)
+
+    assert_raise(ArgumentError) {
+      @klass.new(:name => :invalid)
+    }
+  end
+
+  def test_initialize__port
+    assert_equal(
+      [nil, nil, nil],
+      @klass.new(:port => :all).to_a)
+    assert_equal(
+      [nil, nil, [80]],
+      @klass.new(:port => 80).to_a)
+    assert_equal(
+      [nil, nil, [1, 2, 3]],
+      @klass.new(:port => [3, 2, 1]).to_a)
+    assert_equal(
+      [nil, nil, (1..3)],
+      @klass.new(:port => (1..3)).to_a)
+
+    assert_raise(ArgumentError) {
+      @klass.new(:port => true)
+    }
+  end
+
+  def test_initialize__addr_and_name_and_port
+    assert_equal(
+      [IPAddr.new("127.0.0.1"), "localhost", [80]],
+      @klass.new(:addr => "127.0.0.1", :name => "localhost", :port => 80).to_a)
+  end
+
+  def test_initialize__invalid_parameter
+    assert_raise(ArgumentError) {
+      @klass.new(:invalid)
+    }
+    assert_raise(ArgumentError) {
+      @klass.new(:invalid => true)
+    }
+  end
+
+  #
+  # インスタンスメソッド
+  #
+
+  def test_equal
+    assert_equal(true,  (@klass.new == @klass.new))
+    assert_equal(false, (@klass.new == nil))
+    assert_equal(false, (@klass.new == @klass.new(:addr => "127.0.0.1")))
+    assert_equal(false, (@klass.new == @klass.new(:name => "localhost")))
+    assert_equal(false, (@klass.new == @klass.new(:port => 80)))
+  end
+
+  def test_match__all
+    entry = @klass.new
+    assert_equal(true, entry.match?(nil, nil, nil))
+    assert_equal(true, entry.match?("127.0.0.1", nil, nil))
+    assert_equal(true, entry.match?(nil, "localhost", nil))
+    assert_equal(true, entry.match?(nil, nil, 80))
+  end
+
+  def test_match__addr
+    entry = @klass.new(:addr => "127.0.0.0/8")
+    assert_equal(false, entry.match?("126.255.255.255", nil, nil))
+    assert_equal(true,  entry.match?("127.0.0.0",       nil, nil))
+    assert_equal(true,  entry.match?("127.255.255.255", nil, nil))
+    assert_equal(false, entry.match?("128.0.0.0",       nil, nil))
+
+    entry = @klass.new(:addr => "127.0.0.1")
+    assert_equal(true,  entry.match?("127.0.0.1", "localhost", 80))
+    assert_equal(true,  entry.match?("127.0.0.1", "google.co.jp", 8080))
+    assert_equal(false, entry.match?("192.168.0.1", "localhost", 443))
+  end
+
+  def test_match__name
+    entry = @klass.new(:name => "localhost")
+    assert_equal(true,  entry.match?(nil, "localhost", nil))
+    assert_equal(true,  entry.match?(nil, "LOCALHOST", nil))
+    assert_equal(false, entry.match?(nil, "google.co.jp", nil))
+
+    entry = @klass.new(:name => /\.co\.jp$/)
+    assert_equal(false, entry.match?(nil, "localhost", nil))
+    assert_equal(true,  entry.match?(nil, "google.co.jp", nil))
+    assert_equal(true,  entry.match?(nil, "nayutaya.co.jp", nil))
+
+    entry = @klass.new(:name => "localhost")
+    assert_equal(true,  entry.match?("127.0.0.1", "localhost", 80))
+    assert_equal(false, entry.match?("127.0.0.1", "google.co.jp", 8080))
+    assert_equal(true,  entry.match?("192.168.0.1", "localhost", 443))
+  end
+
+  def test_match__port
+    entry = @klass.new(:port => 80)
+    assert_equal(false, entry.match?(nil, nil, 79))
+    assert_equal(true,  entry.match?(nil, nil, 80))
+    assert_equal(false, entry.match?(nil, nil, 81))
+  end
+
+  def test_match__addr_and_name
+    entry = @klass.new(:addr => "127.0.0.1", :name => "localhost")
+    assert_equal(true,  entry.match?("127.0.0.1", "localhost", 80))
+    assert_equal(true,  entry.match?("127.0.0.1", "localhost", nil))
+    assert_equal(false, entry.match?("127.0.0.1", "google.co.jp", 80))
+    assert_equal(false, entry.match?("192.168.0.1", "localhost", 80))
+  end
+
+  def test_match__addr_and_port
+    entry = @klass.new(:addr => "127.0.0.1", :port => 80)
+    assert_equal(true,  entry.match?("127.0.0.1", "localhost", 80))
+    assert_equal(true,  entry.match?("127.0.0.1", nil, 80))
+    assert_equal(false, entry.match?("127.0.0.1", "localhost", 8080))
+    assert_equal(false, entry.match?("192.168.0.1", "localhost", 80))
+  end
+
+  def test_match_name_and_port
+    entry = @klass.new(:name => "localhost", :port => 80)
+    assert_equal(true,  entry.match?("127.0.0.1", "localhost", 80))
+    assert_equal(true,  entry.match?(nil, "localhost", 80))
+    assert_equal(false, entry.match?("127.0.0.1", "google.co.jp", 80))
+    assert_equal(false, entry.match?("127.0.0.1", "localhost", 8080))
+  end
+
+  def test_match_addr_and_name_and_port
+    entry = @klass.new(:addr => "127.0.0.1", :name => "localhost", :port => 80)
+    assert_equal(true,  entry.match?("127.0.0.1", "localhost", 80))
+    assert_equal(false, entry.match?("192.168.0.1", "localhost", 80))
+    assert_equal(false, entry.match?("127.0.0.1", "google.co.jp", 80))
+    assert_equal(false, entry.match?("127.0.0.1", "localhost", 8080))
+  end
+
+  def test_value
+    assert_raise(NotImplementedError) {
+      @klass.new.value
+    }
+  end
+
+  def test_to_a
+    assert_equal(
+      [nil, nil, nil],
+      @klass.new.to_a)
+  end
+
+  def test_match_addr?
+    entry = @klass.new
+    assert_equal(true, entry.instance_eval { match_addr?(nil) })
+    assert_equal(true, entry.instance_eval { match_addr?(IPAddr.new("10.0.0.0")) })
+    assert_equal(true, entry.instance_eval { match_addr?(IPAddr.new("172.16.0.0")) })
+    assert_equal(true, entry.instance_eval { match_addr?(IPAddr.new("192.168.0.0")) })
+
+    entry = @klass.new(:addr => "10.0.0.0/8")
+    assert_equal(false, entry.instance_eval { match_addr?(nil) })
+    assert_equal(true,  entry.instance_eval { match_addr?(IPAddr.new("10.0.0.0")) })
+    assert_equal(false, entry.instance_eval { match_addr?(IPAddr.new("172.16.0.0")) })
+    assert_equal(false, entry.instance_eval { match_addr?(IPAddr.new("192.168.0.0")) })
+  end
+
+  def test_match_name?
+    entry = @klass.new
+    assert_equal(true, entry.instance_eval { match_name?(nil) })
+    assert_equal(true, entry.instance_eval { match_name?("localhost") })
+    assert_equal(true, entry.instance_eval { match_name?("google.co.jp") })
+
+    entry = @klass.new(:name => "LocalHost")
+    assert_equal(false, entry.instance_eval { match_name?(nil) })
+    assert_equal(true,  entry.instance_eval { match_name?("localhost") })
+    assert_equal(false, entry.instance_eval { match_name?("google.co.jp") })
+
+    entry = @klass.new(:name => /\.co\.jp$/)
+    assert_equal(false, entry.instance_eval { match_name?(nil) })
+    assert_equal(false, entry.instance_eval { match_name?("localhost") })
+    assert_equal(true,  entry.instance_eval { match_name?("google.co.jp") })
+  end
+
+  def test_match_port?
+    entry = @klass.new
+    assert_equal(true, entry.instance_eval { match_port?(nil) })
+    assert_equal(true, entry.instance_eval { match_port?(0) })
+    assert_equal(true, entry.instance_eval { match_port?(1) })
+    assert_equal(true, entry.instance_eval { match_port?(2) })
+
+    entry = @klass.new(:port => 1)
+    assert_equal(false, entry.instance_eval { match_port?(nil) })
+    assert_equal(false, entry.instance_eval { match_port?(0) })
+    assert_equal(true,  entry.instance_eval { match_port?(1) })
+    assert_equal(false, entry.instance_eval { match_port?(2) })
+
+    entry = @klass.new(:port => [0, 1])
+    assert_equal(false, entry.instance_eval { match_port?(nil) })
+    assert_equal(true,  entry.instance_eval { match_port?(0) })
+    assert_equal(true,  entry.instance_eval { match_port?(1) })
+    assert_equal(false, entry.instance_eval { match_port?(2) })
+
+    entry = @klass.new(:port => 1..2)
+    assert_equal(false, entry.instance_eval { match_port?(nil) })
+    assert_equal(false, entry.instance_eval { match_port?(0) })
+    assert_equal(true,  entry.instance_eval { match_port?(1) })
+    assert_equal(true,  entry.instance_eval { match_port?(2) })
+  end
+end

data/test/acl_test.rb

@@ -26,7 +26,7 @@ class AclTest < Test::Unit::TestCase
   def test_self_with__allow_and_deny
     acl = @klass.with {
       allow :all
-      deny :all
+      deny  :all
     }
     assert_equal(2, acl.size)
   end
@@ -37,23 +37,89 @@ class AclTest < Test::Unit::TestCase
     }
   end
 
+  def test_self_allow_all
+    assert_equal(
+      @klass.with { allow :all },
+      @klass.allow_all)
+  end
+
+  def test_self_deny_all
+    assert_equal(
+      @klass.with { deny :all },
+      @klass.deny_all)
+  end
+
+  def test_self_ipaddr?
+    assert_equal(true,  @klass.ipaddr?("127.0.0.1"))
+    assert_equal(true,  @klass.ipaddr?(IPAddr.new("127.0.0.1")))
+    assert_equal(false, @klass.ipaddr?("localhost"))
+    assert_equal(false, @klass.ipaddr?("google.co.jp"))
+  end
+
+  def test_self_create_matching_targets__addr
+    assert_equal(
+      [[IPAddr.new("127.0.0.1"), nil, 80]],
+      @klass.create_matching_targets("127.0.0.1", 80))
+    assert_equal(
+      [[IPAddr.new("192.168.0.1"), nil, 8080]],
+      @klass.create_matching_targets("192.168.0.1", 8080))
+  end
+
+  def test_self_create_matching_targets__name
+    musha = Kagemusha.new(TCPSocket)
+    musha.defs(:gethostbyname) {
+      ["google.co.jp", [], 2, "72.14.203.104", "74.125.91.104", "74.125.95.104"]
+    }
+    expected = [
+      [IPAddr.new("72.14.203.104"), "google.co.jp", 80],
+      [IPAddr.new("74.125.91.104"), "google.co.jp", 80],
+      [IPAddr.new("74.125.95.104"), "google.co.jp", 80],
+    ]
+    assert_equal(
+      expected,
+      musha.swap { @klass.create_matching_targets("google.co.jp", 80) })
+  end
+
   #
   # インスタンスメソッド
   #
 
+  def test_equal__empty
+    a, b = @klass.new, @klass.new
+    assert_equal(true, (a == b))
+  end
+
+  def test_equal__same_size_but_not_equal
+    a, b = @klass.new, @klass.new
+    a.add_allow(:addr => "127.0.0.0/8")
+    b.add_deny(:addr => "127.0.0.0/8")
+    assert_equal(false, (a == b))
+  end
+
+  def test_equal__same
+    a, b = @klass.new, @klass.new
+    a.add_allow(:addr => "127.0.0.0/8")
+    b.add_allow(:addr => "127.0.0.0/8")
+    assert_equal(true, (a == b))
+  end
+
+  def test_equal__other_class
+    assert_equal(false, (@klass.new == nil))
+  end
+
   def test_add_allow
     assert_equal(0, @acl.size)
-    @acl.add_allow("0.0.0.0/0")
+    @acl.add_allow(:addr => "0.0.0.0/0")
     assert_equal(1, @acl.size)
-    @acl.add_allow("0.0.0.0/0")
+    @acl.add_allow(:addr => "0.0.0.0/0")
     assert_equal(2, @acl.size)
   end
 
   def test_add_deny
     assert_equal(0, @acl.size)
-    @acl.add_deny("0.0.0.0/0")
+    @acl.add_deny(:addr => "0.0.0.0/0")
     assert_equal(1, @acl.size)
-    @acl.add_deny("0.0.0.0/0")
+    @acl.add_deny(:addr => "0.0.0.0/0")
     assert_equal(2, @acl.size)
   end
 
@@ -80,24 +146,24 @@ class AclTest < Test::Unit::TestCase
 
   def test_allow?
     assert_equal(true, @acl.allow?("127.0.0.1"))
-    @acl.add_deny("127.0.0.0/8")
-    assert_equal(false, @acl.allow?("127.0.0.1"))
-    @acl.add_allow("127.0.0.0/8")
-    assert_equal(true, @acl.allow?("127.0.0.1"))
+    @acl.add_deny(:addr => "127.0.0.0/8")
+    assert_equal(false, @acl.allow?("127.0.0.1", 80))
+    @acl.add_allow(:port => 80)
+    assert_equal(true, @acl.allow?("127.0.0.1", 80))
   end
 
   def test_deny?
     assert_equal(false, @acl.deny?("127.0.0.1"))
-    @acl.add_deny("127.0.0.0/8")
-    assert_equal(true, @acl.deny?("127.0.0.1"))
-    @acl.add_allow("127.0.0.0/8")
-    assert_equal(false, @acl.deny?("127.0.0.1"))
+    @acl.add_deny(:addr => "127.0.0.0/8")
+    assert_equal(true, @acl.deny?("127.0.0.1", 80))
+    @acl.add_allow(:port => 80)
+    assert_equal(false, @acl.deny?("127.0.0.1", 80))
   end
 
   def test_complex1
     @acl.with {
-      deny :all
-      allow "127.0.0.0/8"
+      deny  :all
+      allow :addr => "127.0.0.0/8"
     }
 
     assert_equal(false, @acl.allow?("126.255.255.255"))
@@ -108,10 +174,10 @@ class AclTest < Test::Unit::TestCase
 
   def test_complex2
     @acl.with {
-      deny :all
-      allow "192.168.1.0/24"
-      allow "192.168.3.0/24"
-      deny "192.168.1.127"
+      deny  :all
+      allow :addr => "192.168.1.0/24"
+      allow :addr => "192.168.3.0/24"
+      deny  :addr => "192.168.1.127"
     }
 
     assert_equal(false, @acl.allow?("192.168.0.0"))
@@ -123,23 +189,54 @@ class AclTest < Test::Unit::TestCase
     assert_equal(true,  @acl.allow?("192.168.3.255"))
   end
 
-  #
-  # RecordBaseクラス
-  #
+  def test_complex3
+    @acl.with {
+      deny  :all
+      allow :port => 80
+      deny  :name => "localhost"
+    }
 
-  def test_record_base_initialize
-    assert_equal(
-      IPAddr.new("127.0.0.0/8"),
-      @klass::RecordBase.new(IPAddr.new("127.0.0.0/8")).ipaddr)
-    assert_equal(
-      IPAddr.new("127.0.0.0/8"),
-      @klass::RecordBase.new("127.0.0.0/8").ipaddr)
-    assert_equal(
-      IPAddr.new("0.0.0.0/0"),
-      @klass::RecordBase.new(:all).ipaddr)
+    assert_equal(true,  @acl.allow?("127.0.0.1", 80))
+    assert_equal(false, @acl.allow?("localhost", 80))
+    assert_equal(true,  @acl.allow?("google.co.jp", 80))
+  end
 
-    assert_raise(ArgumentError) {
-      @klass::RecordBase.new(:invalid)
+  def test_complex4
+    name, aliases, type, *addresses = TCPSocket.gethostbyname("google.co.jp")
+
+    addresses.each { |addr|
+      acl = @klass.new
+      acl.add_allow(:all)
+      acl.add_deny(:addr => addr)
+      assert_equal(true,  acl.allow?("localhost"))
+      assert_equal(true,  acl.allow?("yahoo.co.jp"))
+      assert_equal(false, acl.allow?("google.co.jp"))
+      assert_equal(false, acl.allow?(addr))
     }
   end
+
+  def test_complex5
+    name, aliases, type, *addresses = TCPSocket.gethostbyname("google.co.jp")
+
+    addresses.each { |addr|
+      acl = @klass.new
+      acl.add_deny(:all)
+      acl.add_allow(:addr => addr)
+      assert_equal(false, acl.allow?("localhost"))
+      assert_equal(false, acl.allow?("yahoo.co.jp"))
+      assert_equal(false, acl.allow?("google.co.jp"))
+      assert_equal(true,  acl.allow?(addr))
+    }
+  end
+
+  def test_complex6
+    name, aliases, type, *addresses = TCPSocket.gethostbyname("google.co.jp")
+
+    @acl.add_deny(:all)
+    addresses.each { |addr| @acl.add_allow(:addr => addr) }
+
+    assert_equal(false, @acl.allow?("localhost"))
+    assert_equal(false, @acl.allow?("yahoo.co.jp"))
+    assert_equal(true,  @acl.allow?("google.co.jp"))
+  end
 end