public_suffix 5.0.0 → 5.0.4

data/test/unit/public_suffix_test.rb

@@ -1,188 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class PublicSuffixTest < Minitest::Test
-
-  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.default = nil
-  end
-
-
-  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_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_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_name_fqdn
-    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_with_custom_list
-    list = PublicSuffix::List.new
-    list << PublicSuffix::Rule.factory("test")
-
-    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_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_nil                      domain.trd
-  end
-
-  def test_self_parse_with_unallowed_domain
-    error = assert_raises(PublicSuffix::DomainNotAllowed) { PublicSuffix.parse("example.bd") }
-    assert_match(/example\.bd/, error.message)
-  end
-
-  def test_self_parse_with_uri
-    error = assert_raises(PublicSuffix::DomainInvalid) { PublicSuffix.parse("http://google.com") }
-    assert_match(%r{http://google\.com}, 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
-
-  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_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.bd")
-  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

data/test/unit/rule_test.rb

@@ -1,222 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class PublicSuffix::RuleTest < Minitest::Test
-
-  def test_factory_should_return_rule_normal
-    rule = PublicSuffix::Rule.factory("com")
-    assert_instance_of PublicSuffix::Rule::Normal, rule
-
-    rule = PublicSuffix::Rule.factory("verona.it")
-    assert_instance_of PublicSuffix::Rule::Normal, rule
-  end
-
-  def test_factory_should_return_rule_exception
-    rule = PublicSuffix::Rule.factory("!british-library.uk")
-    assert_instance_of PublicSuffix::Rule::Exception, rule
-  end
-
-  def test_factory_should_return_rule_wildcard
-    rule = PublicSuffix::Rule.factory("*.do")
-    assert_instance_of PublicSuffix::Rule::Wildcard, rule
-
-    rule = PublicSuffix::Rule.factory("*.sch.uk")
-    assert_instance_of PublicSuffix::Rule::Wildcard, rule
-  end
-
-
-  def test_default_returns_default_wildcard
-    default = PublicSuffix::Rule.default
-    assert_equal PublicSuffix::Rule::Wildcard.build("*"), default
-    assert_equal %w[example tldnotlisted], default.decompose("example.tldnotlisted")
-    assert_equal %w[www.example tldnotlisted], default.decompose("www.example.tldnotlisted")
-  end
-
-end
-
-
-class PublicSuffix::RuleBaseTest < Minitest::Test
-
-  class ::PublicSuffix::Rule::Test < ::PublicSuffix::Rule::Base
-  end
-
-  def setup
-    @klass = PublicSuffix::Rule::Base
-  end
-
-
-  def test_initialize
-    rule = @klass.new(value: "verona.it")
-    assert_instance_of @klass,  rule
-    assert_equal "verona.it",   rule.value
-  end
-
-
-  def test_equality_with_self
-    rule = PublicSuffix::Rule::Base.new(value: "foo")
-    assert_equal rule, rule
-  end
-
-  # rubocop:disable Style/SingleLineMethods
-  def test_equality_with_internals
-    assert_equal @klass.new(value: "foo"), @klass.new(value: "foo")
-    refute_equal @klass.new(value: "foo"), @klass.new(value: "bar")
-    refute_equal @klass.new(value: "foo"), PublicSuffix::Rule::Test.new(value: "foo")
-    refute_equal @klass.new(value: "foo"), PublicSuffix::Rule::Test.new(value: "bar")
-    refute_equal @klass.new(value: "foo"), Class.new { def name; foo; end }.new
-  end
-  # rubocop:enable Style/SingleLineMethods
-
-  def test_match
-    [
-      # standard match
-      [PublicSuffix::Rule.factory("uk"), "uk", true],
-      [PublicSuffix::Rule.factory("uk"), "example.uk", true],
-      [PublicSuffix::Rule.factory("uk"), "example.co.uk", true],
-      [PublicSuffix::Rule.factory("co.uk"), "example.co.uk", true],
-
-      # FIXME
-      # [PublicSuffix::Rule.factory("*.com"), "com", false],
-      [PublicSuffix::Rule.factory("*.com"), "example.com", true],
-      [PublicSuffix::Rule.factory("*.com"), "foo.example.com", true],
-      [PublicSuffix::Rule.factory("!example.com"), "com", false],
-      [PublicSuffix::Rule.factory("!example.com"), "example.com", true],
-      [PublicSuffix::Rule.factory("!example.com"), "foo.example.com", true],
-
-      # TLD mismatch
-      [PublicSuffix::Rule.factory("gk"), "example.uk", false],
-      [PublicSuffix::Rule.factory("gk"), "example.co.uk", false],
-      [PublicSuffix::Rule.factory("co.uk"), "uk", false],
-
-      # general mismatch
-      [PublicSuffix::Rule.factory("uk.co"), "example.co.uk", false],
-      [PublicSuffix::Rule.factory("go.uk"), "example.co.uk", false],
-      [PublicSuffix::Rule.factory("co.uk"), "uk", false],
-
-      # partial matches/mismatches
-      [PublicSuffix::Rule.factory("co"), "example.co.uk", false],
-      [PublicSuffix::Rule.factory("example"), "example.uk", false],
-      [PublicSuffix::Rule.factory("le.it"), "example.it", false],
-      [PublicSuffix::Rule.factory("le.it"), "le.it", true],
-      [PublicSuffix::Rule.factory("le.it"), "foo.le.it", true],
-
-    ].each do |rule, input, expected|
-      assert_equal expected, rule.match?(input)
-    end
-  end
-
-
-  def test_parts
-    assert_raises(NotImplementedError) { @klass.new(value: "com").parts }
-  end
-
-  def test_decompose
-    assert_raises(NotImplementedError) { @klass.new(value: "com").decompose("google.com") }
-  end
-
-end
-
-
-class PublicSuffix::RuleNormalTest < Minitest::Test
-
-  def setup
-    @klass = PublicSuffix::Rule::Normal
-  end
-
-
-  def test_build
-    rule = @klass.build("verona.it")
-    assert_instance_of @klass,              rule
-    assert_equal "verona.it",               rule.value
-    assert_equal "verona.it",               rule.rule
-  end
-
-
-  def test_length
-    assert_equal 1, @klass.build("com").length
-    assert_equal 2, @klass.build("co.com").length
-    assert_equal 3, @klass.build("mx.co.com").length
-  end
-
-  def test_parts
-    assert_equal %w[com], @klass.build("com").parts
-    assert_equal %w[co com], @klass.build("co.com").parts
-    assert_equal %w[mx co com], @klass.build("mx.co.com").parts
-  end
-
-  def test_decompose
-    assert_equal [nil, nil], @klass.build("com").decompose("com")
-    assert_equal %w[example com], @klass.build("com").decompose("example.com")
-    assert_equal %w[foo.example com], @klass.build("com").decompose("foo.example.com")
-  end
-
-end
-
-
-class PublicSuffix::RuleExceptionTest < Minitest::Test
-
-  def setup
-    @klass = PublicSuffix::Rule::Exception
-  end
-
-
-  def test_initialize
-    rule = @klass.build("!british-library.uk")
-    assert_instance_of @klass, rule
-    assert_equal "british-library.uk", rule.value
-    assert_equal "!british-library.uk", rule.rule
-  end
-
-
-  def test_length
-    assert_equal 2, @klass.build("!british-library.uk").length
-    assert_equal 3, @klass.build("!foo.british-library.uk").length
-  end
-
-  def test_parts
-    assert_equal %w[uk], @klass.build("!british-library.uk").parts
-    assert_equal %w[tokyo jp], @klass.build("!metro.tokyo.jp").parts
-  end
-
-  def test_decompose
-    assert_equal [nil, nil], @klass.build("!british-library.uk").decompose("uk")
-    assert_equal %w[british-library uk], @klass.build("!british-library.uk").decompose("british-library.uk")
-    assert_equal %w[foo.british-library uk], @klass.build("!british-library.uk").decompose("foo.british-library.uk")
-  end
-
-end
-
-
-class PublicSuffix::RuleWildcardTest < Minitest::Test
-
-  def setup
-    @klass = PublicSuffix::Rule::Wildcard
-  end
-
-
-  def test_initialize
-    rule = @klass.build("*.aichi.jp")
-    assert_instance_of @klass, rule
-    assert_equal "aichi.jp", rule.value
-    assert_equal "*.aichi.jp", rule.rule
-  end
-
-
-  def test_length
-    assert_equal 2, @klass.build("*.uk").length
-    assert_equal 3, @klass.build("*.co.uk").length
-  end
-
-  def test_parts
-    assert_equal %w[uk], @klass.build("*.uk").parts
-    assert_equal %w[co uk], @klass.build("*.co.uk").parts
-  end
-
-  def test_decompose
-    assert_equal [nil, nil], @klass.build("*.do").decompose("nic.do")
-    assert_equal %w[google co.uk], @klass.build("*.uk").decompose("google.co.uk")
-    assert_equal %w[foo.google co.uk], @klass.build("*.uk").decompose("foo.google.co.uk")
-  end
-
-end