nayutaya-webhook-dispatcher 0.0.1 → 0.0.2

data/test/core_test.rb

@@ -0,0 +1,336 @@
+
+require File.dirname(__FILE__) + "/test_helper"
+require "webhook-dispatcher/core"
+
+class CoreTest < Test::Unit::TestCase
+  def setup
+    @klass = WebHookDispatcher
+    @dispatcher = @klass.new
+
+    @real_access = true
+    @example_jp  = URI.parse("http://example.jp/")
+    @get_request = @klass::Request::Get.new(URI.parse("http://localhost/"))
+    @http_musha  = Kagemusha.new(Net::HTTP)
+  end
+
+  #
+  # 初期化
+  #
+
+  def test_initialize__global_default
+    @klass.open_timeout = nil
+    @klass.read_timeout = nil
+    @klass.user_agent   = nil
+    @klass.acl          = nil
+
+    dispatcher = @klass.new
+    assert_equal(@klass.default_open_timeout, dispatcher.open_timeout)
+    assert_equal(@klass.default_read_timeout, dispatcher.read_timeout)
+    assert_equal(@klass.default_user_agent,   dispatcher.user_agent)
+    assert_equal(@klass.default_acl,          dispatcher.acl)
+  end
+
+  def test_initialize__class_default
+    @klass.open_timeout = 1
+    @klass.read_timeout = 2
+    @klass.user_agent   = "3"
+    @klass.acl          = @klass::Acl.allow_all
+
+    dispatcher = @klass.new
+    assert_equal(1,   dispatcher.open_timeout)
+    assert_equal(2,   dispatcher.read_timeout)
+    assert_equal("3", dispatcher.user_agent)
+    assert_equal(@klass::Acl.allow_all, dispatcher.acl)
+  end
+
+  def test_initialize__parameter
+    @klass.open_timeout = 1
+    @klass.read_timeout = 2
+    @klass.user_agent   = "3"
+    @klass.acl          = @klass::Acl.allow_all
+
+    dispatcher = @klass.new(
+      :open_timeout => 4,
+      :read_timeout => 5,
+      :user_agent   => "6",
+      :acl          => @klass::Acl.deny_all)
+    assert_equal(4,   dispatcher.open_timeout)
+    assert_equal(5,   dispatcher.read_timeout)
+    assert_equal("6", dispatcher.user_agent)
+    assert_equal(@klass::Acl.deny_all, dispatcher.acl)
+  end
+
+  def test_initialize__invalid_parameter
+    assert_raise(ArgumentError) {
+      @klass.new(:invalid => true)
+    }
+  end
+
+  #
+  # クラスメソッド
+  #
+
+  def test_self_open_timeout
+    @klass.open_timeout = 5
+    assert_equal(5, @klass.open_timeout)
+  end
+
+  def test_self_read_timeout
+    @klass.read_timeout = 5
+    assert_equal(5, @klass.read_timeout)
+  end
+
+  def test_self_user_agent
+    @klass.user_agent = "ie"
+    assert_equal("ie", @klass.user_agent)
+  end
+
+  def test_self_acl
+    @klass.acl = @klass::Acl.new
+    assert_equal(@klass::Acl.new, @klass.acl)
+  end
+
+  def test_self_default_open_timeout
+    assert_equal(10, @klass.default_open_timeout)
+  end
+
+  def test_self_default_read_timeout
+    assert_equal(10, @klass.default_read_timeout)
+  end
+
+  def test_self_default_user_agent
+    assert_equal(
+      "webhook-dispatcher #{@klass::VERSION}",
+      @klass.default_user_agent)
+  end
+
+  def test_self_default_acl
+    assert_equal(@klass::Acl.new, @klass.default_acl)
+  end
+
+  def test_self_acl_with
+    @klass.acl_with {
+      allow :all
+    }
+    assert_equal(@klass::Acl.allow_all, @klass.acl)
+  end
+
+  #
+  # インスタンスメソッド
+  #
+
+  def test_open_timeout
+    @dispatcher.open_timeout = 10
+    assert_equal(10, @dispatcher.open_timeout)
+  end
+
+  def test_read_timeout
+    @dispatcher.read_timeout = 10
+    assert_equal(10, @dispatcher.read_timeout)
+  end
+
+  def test_user_agent
+    @dispatcher.user_agent = "firefox"
+    assert_equal("firefox", @dispatcher.user_agent)
+  end
+
+  def test_acl
+    @dispatcher.acl = @klass::Acl.new
+    assert_equal(@klass::Acl.new, @dispatcher.acl)
+  end
+
+  def test_acl_with
+    @dispatcher.acl_with {
+      allow :all
+    }
+    assert_equal(@klass::Acl.allow_all, @dispatcher.acl)
+  end
+
+  def test_request__200_ok
+    @http_musha.def(:start) { Net::HTTPOK.new("1.1", "200", "OK") }
+
+    response = @http_musha.swap { @dispatcher.request(@get_request) }
+    assert_equal(true,     response.success?)
+    assert_equal(:success, response.status)
+    assert_equal(200,      response.http_code)
+
+    assert_equal("OK", response.message)
+    assert_equal(nil, response.exception)
+  end
+
+  def test_request__201_created
+    @http_musha.def(:start) { Net::HTTPCreated.new("1.1", "201", "Created") }
+
+    response = @http_musha.swap { @dispatcher.request(@get_request) }
+    assert_equal(true,     response.success?)
+    assert_equal(:success, response.status)
+    assert_equal(201,      response.http_code)
+
+    assert_equal("Created", response.message)
+    assert_equal(nil, response.exception)
+  end
+
+  def test_request__301_moved_permanently
+    @http_musha.def(:start) { Net::HTTPMovedPermanently.new("1.1", "301", "Moved Permanently") }
+
+    response = @http_musha.swap { @dispatcher.request(@get_request) }
+    assert_equal(false,    response.success?)
+    assert_equal(:failure, response.status)
+    assert_equal(301,      response.http_code)
+
+    assert_equal("Moved Permanently", response.message)
+    assert_equal(nil, response.exception)
+  end
+
+  def test_request__denied
+    request = @get_request
+    @dispatcher.acl_with {
+      allow :all
+      deny :name => request.uri.host, :port => request.uri.port
+    }
+
+    response = @http_musha.swap { @dispatcher.request(@get_request) }
+    assert_equal(false,   response.success?)
+    assert_equal(:denied, response.status)
+    assert_equal(nil,     response.http_code)
+
+    assert_equal("denied.", response.message)
+    assert_equal(nil, response.exception)
+  end
+
+  def test_request__timeout
+    @http_musha.def(:start) { raise(TimeoutError) }
+
+    response = @http_musha.swap { @dispatcher.request(@get_request) }
+    assert_equal(false,    response.success?)
+    assert_equal(:timeout, response.status)
+    assert_equal(nil,      response.http_code)
+
+    assert_equal("timeout.", response.message)
+    assert_kind_of(TimeoutError, response.exception)
+  end
+
+  def test_request__refused
+    @http_musha.def(:start) { raise(Errno::ECONNREFUSED) }
+
+    response = @http_musha.swap { @dispatcher.request(@get_request) }
+    assert_equal(false,    response.success?)
+    assert_equal(:refused, response.status)
+    assert_equal(nil,      response.http_code)
+
+    assert_equal("connection refused.", response.message)
+    assert_kind_of(Errno::ECONNREFUSED, response.exception)
+  end
+
+  def test_request__reset
+    @http_musha.def(:start) { raise(Errno::ECONNRESET) }
+
+    response = @http_musha.swap { @dispatcher.request(@get_request) }
+    assert_equal(false,  response.success?)
+    assert_equal(:reset, response.status)
+    assert_equal(nil,    response.http_code)
+
+    assert_equal("connection reset by peer.", response.message)
+    assert_kind_of(Errno::ECONNRESET, response.exception)
+  end
+
+  def test_request__other_error
+    @http_musha.def(:start) { raise(SocketError, "message.") }
+
+    response = @http_musha.swap { @dispatcher.request(@get_request) }
+    assert_equal(false,  response.success?)
+    assert_equal(:error, response.status)
+    assert_equal(nil,    response.http_code)
+
+    assert_equal("SocketError: message.", response.message)
+    assert_kind_of(SocketError, response.exception)
+  end
+
+  def test_get
+    request = nil
+    musha = Kagemusha.new(@klass)
+    musha.def(:request) { |req| request = req }
+    musha.swap {
+      @dispatcher.get(@example_jp)
+    }
+    assert_kind_of(@klass::Request::Get, request)
+    assert_equal(@example_jp, request.uri)
+  end
+
+  def test_get__request_to_google
+    if @real_access
+      response = @dispatcher.get(URI.parse("http://www.google.co.jp/"))
+      assert_equal(true,     response.success?)
+      assert_equal(:success, response.status)
+      assert_equal(200,      response.http_code)
+      assert_equal("OK",     response.message)
+      assert_equal(nil,      response.exception)
+    end
+  end
+
+  def test_head
+    request = nil
+    musha = Kagemusha.new(@klass)
+    musha.def(:request) { |req| request = req }
+    musha.swap {
+      @dispatcher.head(@example_jp)
+    }
+    assert_kind_of(@klass::Request::Head, request)
+    assert_equal(@example_jp, request.uri)
+  end
+
+  def test_head__request_to_google
+    if @real_access
+      response = @dispatcher.head(URI.parse("http://www.google.co.jp/"))
+      assert_equal(true,     response.success?)
+      assert_equal(:success, response.status)
+      assert_equal(200,      response.http_code)
+      assert_equal("OK",     response.message)
+      assert_equal(nil,      response.exception)
+    end
+  end
+
+  def test_post
+    request = nil
+    musha = Kagemusha.new(@klass)
+    musha.def(:request) { |req| request = req }
+    musha.swap {
+      @dispatcher.post(@example_jp, "body")
+    }
+    assert_kind_of(@klass::Request::Post, request)
+    assert_equal(@example_jp, request.uri)
+    assert_equal("body",      request.body)
+  end
+
+  def test_post__request_to_google
+    if @real_access
+      response = @dispatcher.post(URI.parse("http://www.google.co.jp/"), "")
+      assert_equal(false,    response.success?)
+      assert_equal(:failure, response.status)
+      assert_equal(405,      response.http_code)
+      assert_equal("Method Not Allowed", response.message)
+      assert_equal(nil,      response.exception)
+    end
+  end
+
+  def test_setup_http_connector
+    connector = Net::HTTP.new("example.jp")
+    assert_equal(nil, connector.open_timeout)
+    assert_equal(60,  connector.read_timeout)
+
+    @dispatcher.open_timeout = 10
+    @dispatcher.read_timeout = 20
+    @dispatcher.instance_eval { setup_http_connector(connector) }
+    assert_equal(10, connector.open_timeout)
+    assert_equal(20, connector.read_timeout)
+  end
+
+  def test_setup_http_request
+    response = Net::HTTP::Get.new("/")
+    assert_equal(nil, response["User-Agent"])
+
+    @dispatcher.user_agent = "safari"
+    @dispatcher.instance_eval { setup_http_request(response) }
+    assert_equal("safari", response["User-Agent"])
+  end
+end

data/test/request/base_test.rb

@@ -0,0 +1,45 @@
+
+require File.dirname(__FILE__) + "/../test_helper"
+require "webhook-dispatcher/request/base"
+
+class RequestBaseTest < Test::Unit::TestCase
+  def setup
+    @klass = WebHookDispatcher::Request::Base
+
+    @example_jp  = URI.parse("http://example.jp:8080")
+    @example_com = URI.parse("http://example.com:8080")
+  end
+
+  #
+  # 初期化
+  #
+
+  def test_initialize
+    req = @klass.new(@example_jp)
+    assert_equal(@example_jp, req.instance_eval { @uri })
+  end
+
+  #
+  # インスタンスメソッド
+  #
+
+  def test_uri
+    req = @klass.new(@example_jp)
+    assert_equal(@example_jp, req.uri)
+    req.uri = @example_com
+    assert_equal(@example_com, req.uri)
+  end
+
+  def test_create_http_connector
+    conn = @klass.new(@example_jp).create_http_connector
+    assert_kind_of(Net::HTTP, conn)
+    assert_equal(@example_jp.host, conn.address)
+    assert_equal(@example_jp.port, conn.port)
+  end
+
+  def test_create_http_request
+    assert_raise(NotImplementedError) {
+      @klass.new(@example_jp).create_http_request
+    }
+  end
+end

data/test/request/get_test.rb

@@ -0,0 +1,30 @@
+
+require File.dirname(__FILE__) + "/../test_helper"
+require "webhook-dispatcher/request/get"
+
+class RequestGetTest < Test::Unit::TestCase
+  def setup
+    @klass = WebHookDispatcher::Request::Get
+
+    @example_jp = URI.parse("http://example.jp")
+  end
+
+  #
+  # 初期化
+  #
+
+  def test_initialize
+    req = @klass.new(@example_jp)
+    assert_equal(@example_jp, req.uri)
+  end
+
+  #
+  # インスタンスメソッド
+  #
+
+  def test_create_http_request
+    req = @klass.new(URI.parse("http://example.jp/path?query")).create_http_request
+    assert_kind_of(Net::HTTP::Get, req)
+    assert_equal("/path?query", req.path)
+  end
+end

data/test/request/head_test.rb

@@ -0,0 +1,30 @@
+
+require File.dirname(__FILE__) + "/../test_helper"
+require "webhook-dispatcher/request/head"
+
+class RequestHeadTest < Test::Unit::TestCase
+  def setup
+    @klass = WebHookDispatcher::Request::Head
+
+    @example_jp = URI.parse("http://example.jp")
+  end
+
+  #
+  # 初期化
+  #
+
+  def test_initialize
+    req = @klass.new(@example_jp)
+    assert_equal(@example_jp, req.uri)
+  end
+
+  #
+  # インスタンスメソッド
+  #
+
+  def test_create_http_request
+    req = @klass.new(URI.parse("http://example.jp/path?query")).create_http_request
+    assert_kind_of(Net::HTTP::Head, req)
+    assert_equal("/path?query", req.path)
+  end
+end

data/test/request/post_test.rb

@@ -0,0 +1,45 @@
+
+require File.dirname(__FILE__) + "/../test_helper"
+require "webhook-dispatcher/request/post"
+
+class RequestPostTest < Test::Unit::TestCase
+  def setup
+    @klass = WebHookDispatcher::Request::Post
+
+    @example_jp = URI.parse("http://example.jp")
+  end
+
+  #
+  # 初期化
+  #
+
+  def test_initialize
+    req = @klass.new(@example_jp, "body")
+    assert_equal(@example_jp, req.uri)
+    assert_equal("body",      req.body)
+  end
+
+  def test_initialize__default
+    req = @klass.new(@example_jp)
+    assert_equal(@example_jp, req.uri)
+    assert_equal(nil,         req.body)
+  end
+
+  #
+  # インスタンスメソッド
+  #
+
+  def test_body
+    req = @klass.new(@example_jp, "a")
+    assert_equal("a", req.body)
+    req.body = "b"
+    assert_equal("b", req.body)
+  end
+
+  def test_create_http_request
+    req = @klass.new(URI.parse("http://example.jp/path?query"), "body").create_http_request
+    assert_kind_of(Net::HTTP::Post, req)
+    assert_equal("/path?query", req.path)
+    assert_equal("body",        req.body)
+  end
+end

data/test/response_test.rb

@@ -9,28 +9,25 @@ class ResponseTest < Test::Unit::TestCase
   end
 
   def test_initialize
-    res = @klass.new(
-      :success   => true,
+    response = @klass.new(
       :status    => :success,
       :http_code => 200,
       :message   => "OK",
       :exception => RuntimeError.new)
-    assert_equal(true,     res.success)
-    assert_equal(true,     res.success?)
-    assert_equal(:success, res.status)
-    assert_equal(200,      res.http_code)
-    assert_equal("OK",     res.message)
-    assert_kind_of(RuntimeError, res.exception)
+    assert_equal(true,     response.success?)
+    assert_equal(:success, response.status)
+    assert_equal(200,      response.http_code)
+    assert_equal("OK",     response.message)
+    assert_kind_of(RuntimeError, response.exception)
   end
 
   def test_initialize__default
-    res = @klass.new
-    assert_equal(false,    res.success)
-    assert_equal(false,    res.success?)
-    assert_equal(:unknown, res.status)
-    assert_equal(nil,      res.http_code)
-    assert_equal(nil,      res.message)
-    assert_equal(nil,      res.exception)
+    response = @klass.new
+    assert_equal(false,    response.success?)
+    assert_equal(:unknown, response.status)
+    assert_equal(nil,      response.http_code)
+    assert_equal(nil,      response.message)
+    assert_equal(nil,      response.exception)
   end
 
   def test_initialize__invalid_parameter

data/test/test_helper.rb

@@ -1,4 +1,20 @@
 
 require "test/unit"
+require "rubygems"
+
+gem "nayutaya-kagemusha", ">= 0.0.9"
+require "kagemusha"
+
+begin
+  require "redgreen"
+rescue LoadError
+  # nop
+end
+
+begin
+  require "win32console" if /win32/ =~ RUBY_PLATFORM
+rescue LoadError
+  # nop
+end
 
 $:.unshift(File.dirname(__FILE__) + "/../lib")

data/webhook-dispatcher.gemspec

@@ -5,8 +5,8 @@ Gem::Specification.new do |s|
   s.required_ruby_version     = Gem::Requirement.new(">= 1.8.6")
 
   s.name    = "webhook-dispatcher"
-  s.version = "0.0.1"
-  s.date    = "2009-06-23"
+  s.version = "0.0.2"
+  s.date    = "2009-07-02"
 
   s.authors = ["Yuya Kato"]
   s.email   = "yuyakato@gmail.com"
@@ -20,19 +20,30 @@ Gem::Specification.new do |s|
   s.require_paths     = ["lib"]
 
   s.files = [
+    "README.ja",
+    "Rakefile",
     "example.rb",
+    "lib/webhook-dispatcher.rb",
     "lib/webhook-dispatcher/acl.rb",
+    "lib/webhook-dispatcher/acl/allow_entry.rb",
+    "lib/webhook-dispatcher/acl/deny_entry.rb",
+    "lib/webhook-dispatcher/acl/entry_base.rb",
     "lib/webhook-dispatcher/core.rb",
     "lib/webhook-dispatcher/request/base.rb",
     "lib/webhook-dispatcher/request/get.rb",
+    "lib/webhook-dispatcher/request/head.rb",
+    "lib/webhook-dispatcher/request/post.rb",
     "lib/webhook-dispatcher/response.rb",
     "lib/webhook-dispatcher/version.rb",
-    "lib/webhook-dispatcher.rb",
-    "Rakefile",
-    "README.ja",
+    "test/acl/allow_entry_test.rb",
+    "test/acl/deny_entry_test.rb",
+    "test/acl/entry_base_test.rb",
     "test/acl_test.rb",
-    "test/request_base_test.rb",
-    "test/request_get_test.rb",
+    "test/core_test.rb",
+    "test/request/base_test.rb",
+    "test/request/get_test.rb",
+    "test/request/head_test.rb",
+    "test/request/post_test.rb",
     "test/response_test.rb",
     "test/test_helper.rb",
     "webhook-dispatcher.gemspec",
@@ -40,12 +51,9 @@ Gem::Specification.new do |s|
   ]
   s.test_files = [
     "test/acl_test.rb",
-    "test/request_base_test.rb",
-    "test/request_get_test.rb",
+    "test/core_test.rb",
     "test/response_test.rb",
     "test/test_helper.rb",
   ]
-  s.extra_rdoc_files = [
-    "README.ja",
-  ]
+  s.extra_rdoc_files = []
 end

data/webhook-dispatcher.gemspec.erb

@@ -29,7 +29,5 @@ Gem::Specification.new do |s|
     <%= path.dump %>,
 <%- } -%>
   ]
-  s.extra_rdoc_files = [
-    "README.ja",
-  ]
+  s.extra_rdoc_files = []
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: nayutaya-webhook-dispatcher
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Yuya Kato
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-23 00:00:00 -07:00
+date: 2009-07-02 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -19,22 +19,33 @@ executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- README.ja
+extra_rdoc_files: []
+
 files: 
+- README.ja
+- Rakefile
 - example.rb
+- lib/webhook-dispatcher.rb
 - lib/webhook-dispatcher/acl.rb
+- lib/webhook-dispatcher/acl/allow_entry.rb
+- lib/webhook-dispatcher/acl/deny_entry.rb
+- lib/webhook-dispatcher/acl/entry_base.rb
 - lib/webhook-dispatcher/core.rb
 - lib/webhook-dispatcher/request/base.rb
 - lib/webhook-dispatcher/request/get.rb
+- lib/webhook-dispatcher/request/head.rb
+- lib/webhook-dispatcher/request/post.rb
 - lib/webhook-dispatcher/response.rb
 - lib/webhook-dispatcher/version.rb
-- lib/webhook-dispatcher.rb
-- Rakefile
-- README.ja
+- test/acl/allow_entry_test.rb
+- test/acl/deny_entry_test.rb
+- test/acl/entry_base_test.rb
 - test/acl_test.rb
-- test/request_base_test.rb
-- test/request_get_test.rb
+- test/core_test.rb
+- test/request/base_test.rb
+- test/request/get_test.rb
+- test/request/head_test.rb
+- test/request/post_test.rb
 - test/response_test.rb
 - test/test_helper.rb
 - webhook-dispatcher.gemspec
@@ -67,7 +78,6 @@ specification_version: 2
 summary: webhook-dispatcher
 test_files: 
 - test/acl_test.rb
-- test/request_base_test.rb
-- test/request_get_test.rb
+- test/core_test.rb
 - test/response_test.rb
 - test/test_helper.rb