public_suffix 1.0.0.rc1

data/test/acceptance_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+class AcceptanceTest < Test::Unit::TestCase
+
+  ValidCases = {
+    "google.com" => [nil, "google", "com"],
+    "foo.google.com" => ["foo", "google", "com"],
+
+    "verybritish.co.uk" => [nil, "verybritish", "co.uk"],
+    "foo.verybritish.co.uk" => ["foo", "verybritish", "co.uk"],
+
+    "parliament.uk" => [nil, "parliament", "uk"],
+    "foo.parliament.uk" => ["foo", "parliament", "uk"],
+  }
+
+  def test_valid
+    ValidCases.each do |name, results|
+      domain = PublicSuffix.parse(name)
+      trd, sld, tld = results
+      assert_equal tld, domain.tld, "Invalid tld for '#{name}'"
+      assert_equal sld, domain.sld, "Invalid sld for '#{name}'"
+      assert_equal trd, domain.trd, "Invalid trd for '#{name}'"
+    end
+  end
+
+  InvalidCases = {
+    "nic.ke" => PublicSuffix::DomainNotAllowed,
+  }
+
+  def test_invalid
+    InvalidCases.each do |name, error|
+      assert_raise(error) { PublicSuffix.parse(name) }
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'test/unit'
+require 'mocha'
+
+$:.unshift File.expand_path('../../lib', __FILE__)
+require 'public_suffix'

data/test/unit/domain_test.rb

@@ -0,0 +1,170 @@
+require 'test_helper'
+
+class PublicSuffix::DomainTest < Test::Unit::TestCase
+
+  def setup
+    @klass = PublicSuffix::Domain
+  end
+
+  # Tokenizes given input into labels.
+  def test_self_domain_to_labels
+    assert_equal  %w( com live spaces someone ),
+                  PublicSuffix::Domain.domain_to_labels("someone.spaces.live.com")
+    assert_equal  %w( com zoho wiki leontina23samiko ),
+                  PublicSuffix::Domain.domain_to_labels("leontina23samiko.wiki.zoho.com")
+  end
+
+  # Converts input into String.
+  def test_self_domain_to_labels_converts_input_to_string
+    assert_equal  %w( com live spaces someone ),
+                  PublicSuffix::Domain.domain_to_labels(:"someone.spaces.live.com")
+  end
+
+  # Ignores trailing .
+  def test_self_domain_to_labels_ignores_trailing_dot
+    assert_equal  %w( com live spaces someone ),
+                  PublicSuffix::Domain.domain_to_labels("someone.spaces.live.com")
+    assert_equal  %w( com live spaces someone ),
+                  PublicSuffix::Domain.domain_to_labels(:"someone.spaces.live.com")
+  end
+
+
+  def test_initialize_with_tld
+    domain = @klass.new("com")
+    assert_equal "com",     domain.tld
+    assert_equal nil,       domain.sld
+    assert_equal nil,       domain.trd
+  end
+
+  def test_initialize_with_tld_and_sld
+    domain = @klass.new("com", "google")
+    assert_equal "com",     domain.tld
+    assert_equal "google",  domain.sld
+    assert_equal nil,       domain.trd
+  end
+
+  def test_initialize_with_tld_and_sld_and_trd
+    domain = @klass.new("com", "google", "www")
+    assert_equal "com",     domain.tld
+    assert_equal "google",  domain.sld
+    assert_equal "www",     domain.trd
+  end
+
+
+  def test_to_s
+    assert_equal "com",             @klass.new("com").to_s
+    assert_equal "google.com",      @klass.new("com", "google").to_s
+    assert_equal "www.google.com",  @klass.new("com", "google", "www").to_s
+  end
+
+  def test_to_a
+    assert_equal [nil, nil, "com"],         @klass.new("com").to_a
+    assert_equal [nil, "google", "com"],    @klass.new("com", "google").to_a
+    assert_equal ["www", "google", "com"],  @klass.new("com", "google", "www").to_a
+  end
+
+
+  def test_tld
+    assert_equal "com", @klass.new("com", "google", "www").tld
+  end
+
+  def test_sld
+    assert_equal "google", @klass.new("com", "google", "www").sld
+  end
+
+  def test_trd
+    assert_equal "www", @klass.new("com", "google", "www").trd
+  end
+
+
+  def test_name
+    assert_equal "com",             @klass.new("com").name
+    assert_equal "google.com",      @klass.new("com", "google").name
+    assert_equal "www.google.com",  @klass.new("com", "google", "www").name
+  end
+
+  def test_domain
+    assert_equal nil, @klass.new("com").domain
+    assert_equal nil, @klass.new("zip").domain
+    assert_equal "google.com", @klass.new("com", "google").domain
+    assert_equal "google.zip", @klass.new("zip", "google").domain
+    assert_equal "google.com", @klass.new("com", "google", "www").domain
+    assert_equal "google.zip", @klass.new("zip", "google", "www").domain
+  end
+
+  def test_subdomain
+    assert_equal nil, @klass.new("com").subdomain
+    assert_equal nil, @klass.new("zip").subdomain
+    assert_equal nil, @klass.new("com", "google").subdomain
+    assert_equal nil, @klass.new("zip", "google").subdomain
+    assert_equal "www.google.com", @klass.new("com", "google", "www").subdomain
+    assert_equal "www.google.zip", @klass.new("zip", "google", "www").subdomain
+  end
+
+  def test_rule
+    assert_equal nil,                                      @klass.new("zip").rule
+    assert_equal PublicSuffix::Rule.factory("com"), @klass.new("com").rule
+    assert_equal PublicSuffix::Rule.factory("com"), @klass.new("com", "google").rule
+    assert_equal PublicSuffix::Rule.factory("com"), @klass.new("com", "google", "www").rule
+  end
+
+
+  def test_domain_question
+    assert  @klass.new("com", "google").domain?
+    assert  @klass.new("zip", "google").domain?
+    assert  @klass.new("com", "google", "www").domain?
+    assert !@klass.new("com").domain?
+  end
+
+  def test_subdomain_question
+    assert  @klass.new("com", "google", "www").subdomain?
+    assert  @klass.new("zip", "google", "www").subdomain?
+    assert !@klass.new("com").subdomain?
+    assert !@klass.new("com", "google").subdomain?
+  end
+
+  def test_is_a_domain_question
+    assert  @klass.new("com", "google").is_a_domain?
+    assert  @klass.new("zip", "google").is_a_domain?
+    assert !@klass.new("com", "google", "www").is_a_domain?
+    assert !@klass.new("com").is_a_domain?
+  end
+
+  def test_is_a_subdomain_question
+    assert  @klass.new("com", "google", "www").is_a_subdomain?
+    assert  @klass.new("zip", "google", "www").is_a_subdomain?
+    assert !@klass.new("com").is_a_subdomain?
+    assert !@klass.new("com", "google").is_a_subdomain?
+  end
+
+  def test_valid_question
+    assert !@klass.new("com").valid?
+    assert  @klass.new("com", "example").valid?
+    assert  @klass.new("com", "example", "www").valid?
+
+    # not-assigned
+    assert !@klass.new("zip").valid?
+    assert !@klass.new("zip", "example").valid?
+    assert !@klass.new("zip", "example", "www").valid?
+
+    # not-allowed
+    assert !@klass.new("ke").valid?
+    assert !@klass.new("ke", "example").valid?
+    assert  @klass.new("ke", "example", "www").valid?
+  end
+
+  def test_valid_domain_question
+    assert  @klass.new("com", "google").valid_domain?
+    assert !@klass.new("zip", "google").valid_domain?
+    assert  @klass.new("com", "google", "www").valid_domain?
+    assert !@klass.new("com").valid_domain?
+  end
+
+  def test_valid_subdomain_question
+    assert  @klass.new("com", "google", "www").valid_subdomain?
+    assert !@klass.new("zip", "google", "www").valid_subdomain?
+    assert !@klass.new("com").valid_subdomain?
+    assert !@klass.new("com", "google").valid_subdomain?
+  end
+
+end

data/test/unit/errors_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+class ErrorsTest < Test::Unit::TestCase
+
+  # Inherits from StandardError
+  def test_error_inheritance
+    assert_kind_of  StandardError,
+                    PublicSuffix::Error.new
+  end
+
+  # Inherits from PublicSuffix::Error
+  def test_domain_invalid_inheritance
+    assert_kind_of  PublicSuffix::Error,
+                    PublicSuffix::DomainInvalid.new
+  end
+
+  # Inherits from PublicSuffix::DomainInvalid
+  def test_domain_not_allowed_inheritance
+    assert_kind_of  PublicSuffix::DomainInvalid,
+                    PublicSuffix::DomainNotAllowed.new
+  end
+
+end

data/test/unit/list_test.rb

@@ -0,0 +1,193 @@
+require 'test_helper'
+
+class PublicSuffix::ListTest < Test::Unit::TestCase
+
+  def setup
+    @list = PublicSuffix::List.new
+  end
+
+  def teardown
+    PublicSuffix::List.clear
+  end
+
+
+  def test_initialize
+    assert_instance_of PublicSuffix::List, @list
+    assert_equal 0, @list.length
+  end
+
+  def test_initialize_create_index_when_empty
+    assert_equal({}, @list.indexes)
+  end
+
+  def test_indexes
+    @list = PublicSuffix::List.parse(<<EOS)
+// com : http://en.wikipedia.org/wiki/.com
+com
+
+// uk : http://en.wikipedia.org/wiki/.uk
+*.uk
+*.sch.uk
+!bl.uk
+!british-library.uk
+EOS
+
+    assert !@list.indexes.empty?
+    assert_equal [1,2,3,4], @list.indexes.delete('uk')
+    assert_equal [0], @list.indexes.delete('com')
+    assert @list.indexes.empty?
+  end
+
+
+  def test_equality_with_self
+    list = PublicSuffix::List.new
+    assert_equal list, list
+  end
+
+  def test_equality_with_internals
+    rule = PublicSuffix::Rule.factory("com")
+    assert_equal PublicSuffix::List.new.add(rule), PublicSuffix::List.new.add(rule)
+  end
+
+
+  def test_add
+    assert_equal @list, @list.add(PublicSuffix::Rule.factory(""))
+    assert_equal @list, @list <<  PublicSuffix::Rule.factory("")
+    assert_equal 2, @list.length
+  end
+
+  def test_add_should_recreate_index
+    @list = PublicSuffix::List.parse("com")
+    assert_equal PublicSuffix::Rule.factory("com"), @list.find("google.com")
+    assert_equal nil, @list.find("google.net")
+
+    @list << PublicSuffix::Rule.factory("net")
+    assert_equal PublicSuffix::Rule.factory("com"), @list.find("google.com")
+    assert_equal PublicSuffix::Rule.factory("net"), @list.find("google.net")
+  end
+
+  def test_empty?
+    assert  @list.empty?
+    @list.add(PublicSuffix::Rule.factory(""))
+    assert !@list.empty?
+  end
+
+  def test_size
+    assert_equal 0, @list.length
+    assert_equal @list, @list.add(PublicSuffix::Rule.factory(""))
+    assert_equal 1, @list.length
+  end
+
+  def test_clear
+    assert_equal 0, @list.length
+    assert_equal @list, @list.add(PublicSuffix::Rule.factory(""))
+    assert_equal 1, @list.length
+    assert_equal @list, @list.clear
+    assert_equal 0, @list.length
+  end
+
+
+  def test_find
+    @list = PublicSuffix::List.parse(<<EOS)
+// com : http://en.wikipedia.org/wiki/.com
+com
+
+// uk : http://en.wikipedia.org/wiki/.uk
+*.uk
+*.sch.uk
+!bl.uk
+!british-library.uk
+EOS
+    assert_equal PublicSuffix::Rule.factory("com"),  @list.find("google.com")
+    assert_equal PublicSuffix::Rule.factory("com"),  @list.find("foo.google.com")
+    assert_equal PublicSuffix::Rule.factory("*.uk"), @list.find("google.uk")
+    assert_equal PublicSuffix::Rule.factory("*.uk"), @list.find("google.co.uk")
+    assert_equal PublicSuffix::Rule.factory("*.uk"), @list.find("foo.google.co.uk")
+    assert_equal PublicSuffix::Rule.factory("!british-library.uk"), @list.find("british-library.uk")
+    assert_equal PublicSuffix::Rule.factory("!british-library.uk"), @list.find("foo.british-library.uk")
+  end
+
+  def test_select
+    @list = PublicSuffix::List.parse(<<EOS)
+// com : http://en.wikipedia.org/wiki/.com
+com
+
+// uk : http://en.wikipedia.org/wiki/.uk
+*.uk
+*.sch.uk
+!bl.uk
+!british-library.uk
+EOS
+    assert_equal 2, @list.select("british-library.uk").size
+  end
+
+
+  def test_self_default_getter
+    assert_equal     nil, PublicSuffix::List.send(:class_variable_get, :"@@default")
+    PublicSuffix::List.default
+    assert_not_equal nil, PublicSuffix::List.send(:class_variable_get, :"@@default")
+  end
+
+  def test_self_default_setter
+    PublicSuffix::List.default
+    assert_not_equal nil, PublicSuffix::List.send(:class_variable_get, :"@@default")
+    PublicSuffix::List.default = nil
+    assert_equal     nil, PublicSuffix::List.send(:class_variable_get, :"@@default")
+  end
+
+  def test_self_clear
+    PublicSuffix::List.default
+    assert_not_equal nil, PublicSuffix::List.send(:class_variable_get, :"@@default")
+    PublicSuffix::List.clear
+    assert_equal     nil, PublicSuffix::List.send(:class_variable_get, :"@@default")
+  end
+
+  def test_self_reload
+    PublicSuffix::List.default
+    PublicSuffix::List.expects(:default_definition).returns("")
+
+    PublicSuffix::List.reload
+    assert_equal PublicSuffix::List.new, PublicSuffix::List.default
+  end
+
+
+  def test_self_parse
+    list = PublicSuffix::List.parse(<<EOS)
+// ***** BEGIN LICENSE BLOCK *****
+// Version: MPL 1.1/GPL 2.0/LGPL 2.1
+//
+// ***** END LICENSE BLOCK *****
+
+// ac : http://en.wikipedia.org/wiki/.ac
+ac
+com.ac
+
+// ad : http://en.wikipedia.org/wiki/.ad
+ad
+
+// ar : http://en.wikipedia.org/wiki/.ar
+*.ar
+!congresodelalengua3.ar
+EOS
+
+    assert_instance_of PublicSuffix::List, list
+    assert_equal 5, list.length
+    assert_equal %w(ac com.ac ad *.ar !congresodelalengua3.ar).map { |name| PublicSuffix::Rule.factory(name) }, list.to_a
+  end
+
+  def test_self_parse_should_create_cache
+    list = PublicSuffix::List.parse(<<EOS)
+// com : http://en.wikipedia.org/wiki/.com
+com
+
+// uk : http://en.wikipedia.org/wiki/.uk
+*.uk
+*.sch.uk
+!bl.uk
+!british-library.uk
+EOS
+
+    assert_equal PublicSuffix::Rule.factory("com"), list.find("google.com")
+  end
+
+end

data/test/unit/public_suffix_test.rb

@@ -0,0 +1,85 @@
+require 'test_helper'
+
+class PublicSuffixTest < Test::Unit::TestCase
+
+  def test_self_parse_a_domain_with_tld_and_sld
+    domain = PublicSuffix.parse("example.com")
+    assert_instance_of PublicSuffix::Domain, domain
+    assert_equal "com",     domain.tld
+    assert_equal "example", domain.sld
+    assert_equal nil,       domain.trd
+
+    domain = PublicSuffix.parse("example.co.uk")
+    assert_instance_of PublicSuffix::Domain, domain
+    assert_equal "co.uk",   domain.tld
+    assert_equal "example", domain.sld
+    assert_equal nil,       domain.trd
+  end
+
+  def test_self_parse_a_domain_with_tld_and_sld_and_trd
+    domain = PublicSuffix.parse("alpha.example.com")
+    assert_instance_of PublicSuffix::Domain, domain
+    assert_equal "com",     domain.tld
+    assert_equal "example", domain.sld
+    assert_equal "alpha",   domain.trd
+
+    domain = PublicSuffix.parse("alpha.example.co.uk")
+    assert_instance_of PublicSuffix::Domain, domain
+    assert_equal "co.uk",   domain.tld
+    assert_equal "example", domain.sld
+    assert_equal "alpha",   domain.trd
+  end
+
+  def test_self_parse_a_domain_with_tld_and_sld_and_4rd
+    domain = PublicSuffix.parse("one.two.example.com")
+    assert_instance_of PublicSuffix::Domain, domain
+    assert_equal "com",     domain.tld
+    assert_equal "example", domain.sld
+    assert_equal "one.two", domain.trd
+
+    domain = PublicSuffix.parse("one.two.example.co.uk")
+    assert_instance_of PublicSuffix::Domain, domain
+    assert_equal "co.uk",   domain.tld
+    assert_equal "example", domain.sld
+    assert_equal "one.two", domain.trd
+  end
+
+  def test_self_parse_a_fully_qualified_domain_name
+    domain = PublicSuffix.parse("www.example.com.")
+    assert_instance_of PublicSuffix::Domain, domain
+    assert_equal "com",     domain.tld
+    assert_equal "example", domain.sld
+    assert_equal "www",     domain.trd
+  end
+
+  def test_self_parse_should_raise_with_invalid_domain
+    error = assert_raise(PublicSuffix::DomainInvalid) { PublicSuffix.parse("example.zip") }
+    assert_match %r{example\.zip}, error.message
+  end
+
+  def test_self_parse_should_raise_with_unallowed_domain
+    error = assert_raise(PublicSuffix::DomainNotAllowed) { PublicSuffix.parse("example.ke") }
+    assert_match %r{example\.ke}, error.message
+  end
+
+
+  def test_self_valid
+    assert  PublicSuffix.valid?("google.com")
+    assert  PublicSuffix.valid?("www.google.com")
+    assert  PublicSuffix.valid?("google.co.uk")
+    assert  PublicSuffix.valid?("www.google.co.uk")
+  end
+
+  # Returns false when domain has an invalid TLD
+  def test_self_valid_with_invalid_tld
+    assert !PublicSuffix.valid?("google.zip")
+    assert !PublicSuffix.valid?("www.google.zip")
+  end
+
+  def test_self_valid_with_fully_qualified_domain_name
+    assert  PublicSuffix.valid?("google.com.")
+    assert  PublicSuffix.valid?("google.co.uk.")
+    assert !PublicSuffix.valid?("google.zip.")
+  end
+
+end