public_suffix 1.5.3 → 2.0.0

data/test/unit/errors_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 class ErrorsTest < Minitest::Unit::TestCase
 
@@ -20,4 +20,4 @@ class ErrorsTest < Minitest::Unit::TestCase
                     PublicSuffix::DomainNotAllowed.new
   end
 
-end
+end

data/test/unit/list_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 class PublicSuffix::ListTest < Minitest::Unit::TestCase
 
@@ -13,20 +13,13 @@ class PublicSuffix::ListTest < Minitest::Unit::TestCase
 
   def test_initialize
     assert_instance_of PublicSuffix::List, @list
-    assert_equal 0, @list.length
+    assert_equal 0, @list.size
   end
 
-  def test_initialize_create_index_when_empty
+  def test_initialize_indexes
     assert_equal({}, @list.indexes)
   end
 
-  def test_indexes
-    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
@@ -41,13 +34,13 @@ class PublicSuffix::ListTest < Minitest::Unit::TestCase
   def test_add
     assert_equal @list, @list.add(PublicSuffix::Rule.factory(""))
     assert_equal @list, @list <<  PublicSuffix::Rule.factory("")
-    assert_equal 2, @list.length
+    assert_equal 2, @list.size
   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")
+    assert_equal @list.default_rule, @list.find("google.net")
 
     @list << PublicSuffix::Rule.factory("net")
     assert_equal PublicSuffix::Rule.factory("com"), @list.find("google.com")
@@ -62,57 +55,110 @@ class PublicSuffix::ListTest < Minitest::Unit::TestCase
   end
 
   def test_empty?
-    assert  @list.empty?
+    assert @list.empty?
     @list.add(PublicSuffix::Rule.factory(""))
     assert !@list.empty?
   end
 
   def test_size
-    assert_equal 0, @list.length
+    assert_equal 0, @list.size
     assert_equal @list, @list.add(PublicSuffix::Rule.factory(""))
-    assert_equal 1, @list.length
+    assert_equal 1, @list.size
   end
 
   def test_clear
-    assert_equal 0, @list.length
+    assert_equal 0, @list.size
     assert_equal @list, @list.add(PublicSuffix::Rule.factory(""))
-    assert_equal 1, @list.length
+    assert_equal 1, @list.size
     assert_equal @list, @list.clear
-    assert_equal 0, @list.length
+    assert_equal 0, @list.size
   end
 
 
   def test_find
-    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")
+    list = PublicSuffix::List.parse(<<EOS)
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+// ===BEGIN ICANN DOMAINS===
+
+// com
+com
+
+// uk
+*.uk
+*.sch.uk
+!bl.uk
+!british-library.uk
+
+// io
+io
+
+// ===END ICANN DOMAINS===
+// ===BEGIN PRIVATE DOMAINS===
+
+// Google, Inc.
+blogspot.com
+
+// ===END PRIVATE DOMAINS===
+EOS
+
+    # match IANA
+    assert_equal PublicSuffix::Rule.factory("com"), list.find("example.com")
+    assert_equal PublicSuffix::Rule.factory("com"), list.find("foo.example.com")
+
+    # match wildcard
+    assert_equal PublicSuffix::Rule.factory("*.uk"), list.find("example.uk")
+    assert_equal PublicSuffix::Rule.factory("*.uk"), list.find("example.co.uk")
+    assert_equal PublicSuffix::Rule.factory("*.uk"), list.find("foo.example.co.uk")
+
+    # match exception
     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")
+
+    # match default rule
+    assert_equal PublicSuffix::Rule.factory("*"), list.find("test")
+    assert_equal PublicSuffix::Rule.factory("*"), list.find("example.test")
+    assert_equal PublicSuffix::Rule.factory("*"), list.find("foo.example.test")
+
+    # match private
+    assert_equal PublicSuffix::Rule.factory("blogspot.com", private: true), list.find("blogspot.com")
+    assert_equal PublicSuffix::Rule.factory("blogspot.com", private: true), list.find("foo.blogspot.com")
   end
 
+
   def test_select
     assert_equal 2, list.select("british-library.uk").size
   end
 
-  def test_select_returns_empty_when_domain_is_nil
+  def test_select_name_blank
     assert_equal [], list.select(nil)
-  end
-
-  def test_select_returns_empty_when_domain_is_blank
     assert_equal [], list.select("")
-    assert_equal [], list.select("  ")
+    assert_equal [], list.select(" ")
   end
 
-  def test_select_returns_empty_when_domain_has_scheme
-    assert_equal [], list.select("http://google.com")
-    assert_not_equal [], list.select("google.com")
+  def test_select_ignore_private
+    list = PublicSuffix::List.new
+    list.add r1 = PublicSuffix::Rule.factory("io")
+    list.add r2 = PublicSuffix::Rule.factory("example.io", private: true)
+
+    assert_equal list.select("foo.io"), [r1]
+    assert_equal list.select("example.io"), [r1, r2]
+    assert_equal list.select("foo.example.io"), [r1, r2]
+
+    assert_equal list.select("foo.io", ignore_private: false), [r1]
+    assert_equal list.select("example.io", ignore_private: false), [r1, r2]
+    assert_equal list.select("foo.example.io", ignore_private: false), [r1, r2]
+
+    assert_equal list.select("foo.io", ignore_private: true), [r1]
+    assert_equal list.select("example.io", ignore_private: true), [r1]
+    assert_equal list.select("foo.example.io", ignore_private: true), [r1]
   end
 
 
   def test_self_default_getter
-    assert_equal     nil, PublicSuffix::List.class_eval { @default }
+    assert_equal nil, PublicSuffix::List.class_eval { @default }
     PublicSuffix::List.default
     assert_not_equal nil, PublicSuffix::List.class_eval { @default }
   end
@@ -121,54 +167,80 @@ class PublicSuffix::ListTest < Minitest::Unit::TestCase
     PublicSuffix::List.default
     assert_not_equal nil, PublicSuffix::List.class_eval { @default }
     PublicSuffix::List.default = nil
-    assert_equal     nil, PublicSuffix::List.class_eval { @default }
+    assert_equal nil, PublicSuffix::List.class_eval { @default }
   end
 
   def test_self_clear
     PublicSuffix::List.default
     assert_not_equal nil, PublicSuffix::List.class_eval { @default }
     PublicSuffix::List.clear
-    assert_equal     nil, PublicSuffix::List.class_eval { @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
+    assert_equal nil, PublicSuffix::List.class_eval { @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 *****
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-// ac : http://en.wikipedia.org/wiki/.ac
-ac
-com.ac
+// ===BEGIN ICANN DOMAINS===
 
-// ad : http://en.wikipedia.org/wiki/.ad
-ad
+// com
+com
 
-// ar : http://en.wikipedia.org/wiki/.ar
-*.ar
-!congresodelalengua3.ar
+// uk
+*.uk
+!british-library.uk
+
+// ===END ICANN DOMAINS===
+// ===BEGIN PRIVATE DOMAINS===
+
+// Google, Inc.
+blogspot.com
+
+// ===END PRIVATE DOMAINS===
 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
+    assert_equal 4, list.size
+
+    rules = %w( com *.uk !british-library.uk blogspot.com ).map { |name| PublicSuffix::Rule.factory(name) }
+    assert_equal rules, list.to_a
+
+    # private domains
+    assert_equal false, list.find("com").private
+    assert_equal true,  list.find("blogspot.com").private
   end
 
-  def test_self_parse_should_create_cache
-    assert_equal PublicSuffix::Rule.factory("com"), list.find("google.com")
+  def test_self_parse_indexes
+    list = PublicSuffix::List.parse(<<EOS)
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+// ===BEGIN ICANN DOMAINS===
+
+// com
+com
+
+// uk
+*.uk
+!british-library.uk
+
+// ===END ICANN DOMAINS===
+// ===BEGIN PRIVATE DOMAINS===
+
+// Google, Inc.
+blogspot.com
+
+// ===END PRIVATE DOMAINS===
+EOS
+
+    assert_equal({ "com" => [0, 3], "uk" => [1, 2] }, list.indexes)
   end
 
 
-private
+  private
 
   def list
     @_list ||= PublicSuffix::List.parse(<<EOS)

data/test/unit/public_suffix_test.rb

@@ -1,7 +1,22 @@
-require 'test_helper'
+require "test_helper"
 
 class PublicSuffixTest < Minitest::Unit::TestCase
 
+  def test_private_domains_enabled_by_default
+    domain = PublicSuffix.parse("www.example.blogspot.com")
+    assert_equal "blogspot.com", domain.tld
+  end
+
+  def test_private_domains_disable
+    data = File.read(PublicSuffix::List::DEFAULT_LIST_PATH)
+    PublicSuffix::List.default = PublicSuffix::List.parse(data, private_domains: false)
+    domain = PublicSuffix.parse("www.example.blogspot.com")
+    assert_equal "com", domain.tld
+  ensure
+    PublicSuffix::List.clear
+  end
+
+
   def test_self_parse_a_domain_with_tld_and_sld
     domain = PublicSuffix.parse("example.com")
     assert_instance_of PublicSuffix::Domain, domain
@@ -44,7 +59,7 @@ class PublicSuffixTest < Minitest::Unit::TestCase
     assert_equal "one.two", domain.trd
   end
 
-  def test_self_parse_a_fully_qualified_domain_name
+  def test_self_parse_name_fqdn
     domain = PublicSuffix.parse("www.example.com.")
     assert_instance_of PublicSuffix::Domain, domain
     assert_equal "com",     domain.tld
@@ -52,44 +67,33 @@ class PublicSuffixTest < Minitest::Unit::TestCase
     assert_equal "www",     domain.trd
   end
 
-  def test_private_domains_are_enabled_by_default
-    domain = PublicSuffix.parse("www.example.blogspot.com")
-    assert_equal "blogspot.com",    domain.tld
-  end
-
-  def test_disable_support_for_private_domains
-    begin
-      PublicSuffix::List.private_domains = false
-      domain = PublicSuffix.parse("www.example.blogspot.com")
-      assert_equal "com",    domain.tld
-    ensure
-      PublicSuffix::List.private_domains = true
-    end
-  end
-
-  def test_self_parse_a_domain_with_custom_list
+  def test_self_parse_with_custom_list
     list = PublicSuffix::List.new
     list << PublicSuffix::Rule.factory("test")
 
-    domain = PublicSuffix.parse("www.example.test", list)
+    domain = PublicSuffix.parse("www.example.test", list: list)
+    assert_instance_of PublicSuffix::Domain, domain
     assert_equal "test",    domain.tld
     assert_equal "example", domain.sld
     assert_equal "www",     domain.trd
   end
 
-  def test_self_parse_raises_with_invalid_domain
-    error = assert_raises(PublicSuffix::DomainInvalid) { PublicSuffix.parse("example.qqq") }
-    assert_match %r{example\.qqq}, error.message
+  def test_self_parse_with_notlisted_name
+    domain = PublicSuffix.parse("example.tldnotlisted")
+    assert_instance_of PublicSuffix::Domain, domain
+    assert_equal "tldnotlisted",    domain.tld
+    assert_equal "example",         domain.sld
+    assert_equal nil,               domain.trd
   end
 
-  def test_self_parse_raises_with_unallowed_domain
+  def test_self_parse_with_unallowed_domain
     error = assert_raises(PublicSuffix::DomainNotAllowed) { PublicSuffix.parse("example.ke") }
-    assert_match %r{example\.ke}, error.message
+    assert_match(/example\.ke/, error.message)
   end
 
-  def test_self_raises_with_uri
+  def test_self_parse_with_uri
     error = assert_raises(PublicSuffix::DomainInvalid) { PublicSuffix.parse("http://google.com") }
-    assert_match %r{http://google\.com}, error.message
+    assert_match(%r{http://google\.com}, error.message)
   end
 
 
@@ -100,16 +104,83 @@ class PublicSuffixTest < Minitest::Unit::TestCase
     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.qqq")
-    assert !PublicSuffix.valid?("www.google.qqq")
+  def test_self_valid_with_notlisted_name
+    assert  PublicSuffix.valid?("google.tldnotlisted")
+    assert  PublicSuffix.valid?("www.google.tldnotlisted")
+  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.tldnotlisted.")
+  # end
+
+
+  def test_self_domain
+    assert_equal "google.com",    PublicSuffix.domain("google.com")
+    assert_equal "google.com",    PublicSuffix.domain("www.google.com")
+    assert_equal "google.co.uk",  PublicSuffix.domain("google.co.uk")
+    assert_equal "google.co.uk",  PublicSuffix.domain("www.google.co.uk")
   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.qqq.")
+  def test_self_domain_with_notlisted_name
+    assert_equal "example.tldnotlisted", PublicSuffix.domain("example.tldnotlisted")
+  end
+
+  def test_self_domain_with_unallowed_name
+    assert_nil PublicSuffix.domain("example.ke")
+  end
+
+  def test_self_domain_with_blank_sld
+    assert_nil PublicSuffix.domain("com")
+    assert_nil PublicSuffix.domain(".com")
+  end
+
+
+  def test_self_normalize
+    [
+        ["com", "com"],
+        ["example.com", "example.com"],
+        ["www.example.com", "www.example.com"],
+
+        ["example.com.",  "example.com"],     # strip FQDN
+        [" example.com ", "example.com"],     # strip spaces
+        ["Example.COM",   "example.com"],     # downcase
+    ].each do |input, output|
+      assert_equal output, PublicSuffix.normalize(input)
+    end
+  end
+
+  def test_normalize_blank
+    [
+        nil,
+        "",
+        " ",
+    ].each do |input, _|
+      error = PublicSuffix.normalize(input)
+      assert_instance_of PublicSuffix::DomainInvalid, error
+      assert_equal "Name is blank", error.message
+    end
+  end
+
+  def test_normalize_scheme
+    [
+        "https://google.com",
+    ].each do |input, _|
+      error = PublicSuffix.normalize(input)
+      assert_instance_of PublicSuffix::DomainInvalid, error
+      assert_match /scheme/, error.message
+    end
+  end
+
+  def test_normalize_leading_dot
+    [
+        ".google.com",
+    ].each do |input, _|
+      error = PublicSuffix.normalize(input)
+      assert_instance_of PublicSuffix::DomainInvalid, error
+      assert_match "Name starts with a dot", error.message
+    end
   end
 
 end