public_suffix_service 0.4.0

data/test/public_suffix_service/rule_list_test.rb

@@ -0,0 +1,182 @@
+require 'test_helper'
+
+class PublicSuffixService::RuleListTest < Test::Unit::TestCase
+
+  def setup
+    @list = PublicSuffixService::RuleList.new
+  end
+
+  def teardown
+    PublicSuffixService::RuleList.clear
+  end
+
+
+  def test_initialize
+    assert_instance_of PublicSuffixService::RuleList, @list
+    assert_equal 0, @list.length
+  end
+
+
+  def test_equality_with_self
+    list = PublicSuffixService::RuleList.new
+    assert_equal list, list
+  end
+
+  def test_equality_with_internals
+    rule = PublicSuffixService::Rule.factory("com")
+    assert_equal PublicSuffixService::RuleList.new.add(rule), PublicSuffixService::RuleList.new.add(rule)
+  end
+
+
+  def test_add
+    assert_equal @list, @list.add(PublicSuffixService::Rule.factory(""))
+    assert_equal @list, @list <<  PublicSuffixService::Rule.factory("")
+    assert_equal 2, @list.length
+  end
+
+  def test_empty?
+    assert  @list.empty?
+    @list.add(PublicSuffixService::Rule.factory(""))
+    assert !@list.empty?
+  end
+
+  def test_size
+    assert_equal 0, @list.length
+    assert_equal @list, @list.add(PublicSuffixService::Rule.factory(""))
+    assert_equal 1, @list.length
+  end
+
+  def test_clear
+    assert_equal 0, @list.length
+    assert_equal @list, @list.add(PublicSuffixService::Rule.factory(""))
+    assert_equal 1, @list.length
+    assert_equal @list, @list.clear
+    assert_equal 0, @list.length
+  end
+
+
+  def test_find
+    @list = PublicSuffixService::RuleList.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 PublicSuffixService::Rule.factory("com"),  @list.find("google.com")
+    assert_equal PublicSuffixService::Rule.factory("com"),  @list.find("foo.google.com")
+    assert_equal PublicSuffixService::Rule.factory("*.uk"), @list.find("google.uk")
+    assert_equal PublicSuffixService::Rule.factory("*.uk"), @list.find("google.co.uk")
+    assert_equal PublicSuffixService::Rule.factory("*.uk"), @list.find("foo.google.co.uk")
+    assert_equal PublicSuffixService::Rule.factory("!british-library.uk"), @list.find("british-library.uk")
+    assert_equal PublicSuffixService::Rule.factory("!british-library.uk"), @list.find("foo.british-library.uk")
+  end
+
+  def test_select
+    @list = PublicSuffixService::RuleList.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, PublicSuffixService::RuleList.send(:class_variable_get, :"@@default")
+    PublicSuffixService::RuleList.default
+    assert_not_equal nil, PublicSuffixService::RuleList.send(:class_variable_get, :"@@default")
+  end
+
+  def test_self_default_setter
+    PublicSuffixService::RuleList.default
+    assert_not_equal nil, PublicSuffixService::RuleList.send(:class_variable_get, :"@@default")
+    PublicSuffixService::RuleList.default = nil
+    assert_equal     nil, PublicSuffixService::RuleList.send(:class_variable_get, :"@@default")
+  end
+
+  def test_self_clear
+    PublicSuffixService::RuleList.default
+    assert_not_equal nil, PublicSuffixService::RuleList.send(:class_variable_get, :"@@default")
+    PublicSuffixService::RuleList.clear
+    assert_equal     nil, PublicSuffixService::RuleList.send(:class_variable_get, :"@@default")
+  end
+
+  def test_self_reload
+    PublicSuffixService::RuleList.default
+    PublicSuffixService::RuleList.expects(:default_definition).returns("")
+    PublicSuffixService::RuleList.reload
+    assert_equal PublicSuffixService::RuleList.new, PublicSuffixService::RuleList.default
+  end
+
+  def test_self_parse
+    input = <<EOS
+// ***** BEGIN LICENSE BLOCK *****
+// Version: MPL 1.1/GPL 2.0/LGPL 2.1
+//
+// The contents of this file are subject to the Mozilla Public License Version
+// 1.1 (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+// http://www.mozilla.org/MPL/
+//
+// Software distributed under the License is distributed on an "AS IS" basis,
+// WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+// for the specific language governing rights and limitations under the
+// License.
+//
+// The Original Code is the Public Suffix List.
+//
+// The Initial Developer of the Original Code is
+// Jo Hermans <jo.hermans@gmail.com>.
+// Portions created by the Initial Developer are Copyright (C) 2007
+// the Initial Developer. All Rights Reserved.
+//
+// Contributor(s):
+//   Ruben Arakelyan <ruben@wackomenace.co.uk>
+//   Gervase Markham <gerv@gerv.net>
+//   Pamela Greene <pamg.bugs@gmail.com>
+//   David Triendl <david@triendl.name>
+//   The kind representatives of many TLD registries
+//
+// Alternatively, the contents of this file may be used under the terms of
+// either the GNU General Public License Version 2 or later (the "GPL"), or
+// the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+// in which case the provisions of the GPL or the LGPL are applicable instead
+// of those above. If you wish to allow use of your version of this file only
+// under the terms of either the GPL or the LGPL, and not to allow others to
+// use your version of this file under the terms of the MPL, indicate your
+// decision by deleting the provisions above and replace them with the notice
+// and other provisions required by the GPL or the LGPL. If you do not delete
+// the provisions above, a recipient may use your version of this file under
+// the terms of any one of the MPL, the GPL or the LGPL.
+//
+// ***** 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
+    expected = []
+    list = PublicSuffixService::RuleList.parse(input)
+
+    assert_instance_of PublicSuffixService::RuleList, list
+    assert_equal 5, list.length
+    assert_equal %w(ac com.ac ad *.ar !congresodelalengua3.ar).map { |name| PublicSuffixService::Rule.factory(name) }, list.to_a
+  end
+
+end

data/test/public_suffix_service/rule_test.rb

@@ -0,0 +1,215 @@
+require 'test_helper'
+
+class PublicSuffixService::RuleTest < Test::Unit::TestCase
+
+  def test_factory_should_return_rule_normal
+    rule = PublicSuffixService::Rule.factory("verona.it")
+    assert_instance_of PublicSuffixService::Rule::Normal, rule
+  end
+
+  def test_factory_should_return_rule_exception
+    rule = PublicSuffixService::Rule.factory("!british-library.uk")
+    assert_instance_of PublicSuffixService::Rule::Exception, rule
+  end
+
+  def test_factory_should_return_rule_wildcard
+    rule = PublicSuffixService::Rule.factory("*.aichi.jp")
+    assert_instance_of PublicSuffixService::Rule::Wildcard, rule
+  end
+
+end
+
+
+class PublicSuffixService::RuleBaseTest < Test::Unit::TestCase
+
+  class ::PublicSuffixService::Rule::Test < ::PublicSuffixService::Rule::Base
+  end
+
+  def setup
+    @klass = PublicSuffixService::Rule::Base
+  end
+
+
+  def test_initialize
+    rule = @klass.new("verona.it")
+    assert_instance_of @klass,          rule
+
+    assert_equal :base,                 rule.type
+    assert_equal "verona.it",           rule.name
+    assert_equal "verona.it",           rule.value
+    assert_equal %w(verona it).reverse, rule.labels
+  end
+
+  def test_equality_with_self
+    rule = PublicSuffixService::Rule::Base.new("foo")
+    assert_equal rule, rule
+  end
+
+  def test_equality_with_internals
+    assert_equal      @klass.new("foo"), @klass.new("foo")
+    assert_not_equal  @klass.new("foo"), @klass.new("bar")
+    assert_not_equal  @klass.new("foo"), PublicSuffixService::Rule::Test.new("bar")
+    assert_not_equal  @klass.new("foo"), Class.new { def name; foo; end }.new
+  end
+
+
+  def test_match
+    assert  @klass.new("uk").match?("google.uk")
+    assert !@klass.new("gk").match?("google.uk")
+    assert !@klass.new("google").match?("google.uk")
+    assert  @klass.new("uk").match?("google.co.uk")
+    assert !@klass.new("gk").match?("google.co.uk")
+    assert !@klass.new("co").match?("google.co.uk")
+    assert  @klass.new("co.uk").match?("google.co.uk")
+    assert !@klass.new("uk.co").match?("google.co.uk")
+    assert !@klass.new("go.uk").match?("google.co.uk")
+  end
+
+  def test_length
+    assert_raise(NotImplementedError) { @klass.new("com").length }
+  end
+
+  def test_parts
+    assert_raise(NotImplementedError) { @klass.new("com").parts }
+  end
+
+  def test_decompose
+    assert_raise(NotImplementedError) { @klass.new("com").decompose("google.com") }
+  end
+
+end
+
+
+class PublicSuffixService::RuleNormalTest < Test::Unit::TestCase
+
+  def setup
+    @klass = PublicSuffixService::Rule::Normal
+  end
+
+
+  def test_initialize
+    rule = @klass.new("verona.it")
+    assert_instance_of @klass,              rule
+    assert_equal :normal,                   rule.type
+    assert_equal "verona.it",               rule.name
+    assert_equal "verona.it",               rule.value
+    assert_equal %w(verona it).reverse,     rule.labels
+  end
+
+
+  def test_match
+    assert  @klass.new("uk").match?("google.uk")
+    assert !@klass.new("gk").match?("google.uk")
+    assert !@klass.new("google").match?("google.uk")
+    assert  @klass.new("uk").match?("google.co.uk")
+    assert !@klass.new("gk").match?("google.co.uk")
+    assert !@klass.new("co").match?("google.co.uk")
+    assert  @klass.new("co.uk").match?("google.co.uk")
+    assert !@klass.new("uk.co").match?("google.co.uk")
+    assert !@klass.new("go.uk").match?("google.co.uk")
+  end
+
+  def test_length
+    assert_equal 1, @klass.new("com").length
+    assert_equal 2, @klass.new("co.com").length
+    assert_equal 3, @klass.new("mx.co.com").length
+  end
+
+  def test_parts
+    assert_equal %w(com), @klass.new("com").parts
+    assert_equal %w(co com), @klass.new("co.com").parts
+    assert_equal %w(mx co com), @klass.new("mx.co.com").parts
+  end
+
+  def test_decompose
+    assert_equal %w(google com), @klass.new("com").decompose("google.com")
+    assert_equal %w(foo.google com), @klass.new("com").decompose("foo.google.com")
+  end
+
+end
+
+
+class PublicSuffixService::RuleExceptionTest < Test::Unit::TestCase
+
+  def setup
+    @klass = PublicSuffixService::Rule::Exception
+  end
+
+
+  def test_initialize
+    rule = @klass.new("!british-library.uk")
+    assert_instance_of @klass,                    rule
+    assert_equal :exception,                      rule.type
+    assert_equal "!british-library.uk",           rule.name
+    assert_equal "british-library.uk",            rule.value
+    assert_equal %w(british-library uk).reverse,  rule.labels
+  end
+
+
+  def test_match
+    assert  @klass.new("!uk").match?("google.co.uk")
+    assert !@klass.new("!gk").match?("google.co.uk")
+    assert  @klass.new("!co.uk").match?("google.co.uk")
+    assert !@klass.new("!go.uk").match?("google.co.uk")
+    assert  @klass.new("!british-library.uk").match?("british-library.uk")
+    assert !@klass.new("!british-library.uk").match?("google.co.uk")
+  end
+
+  def test_length
+    assert_equal 1, @klass.new("!british-library.uk").length
+    assert_equal 2, @klass.new("!foo.british-library.uk").length
+  end
+
+  def test_parts
+    assert_equal %w(uk), @klass.new("!british-library.uk").parts
+    assert_equal %w(tokyo jp), @klass.new("!metro.tokyo.jp").parts
+  end
+
+  def test_decompose
+    assert_equal %w(british-library uk), @klass.new("!british-library.uk").decompose("british-library.uk")
+    assert_equal %w(foo.british-library uk), @klass.new("!british-library.uk").decompose("foo.british-library.uk")
+  end
+
+end
+
+
+class PublicSuffixService::RuleWildcardTest < Test::Unit::TestCase
+
+  def setup
+    @klass = PublicSuffixService::Rule::Wildcard
+  end
+
+
+  def test_initialize
+    rule = @klass.new("*.aichi.jp")
+    assert_instance_of @klass,              rule
+    assert_equal :wildcard,                 rule.type
+    assert_equal "*.aichi.jp",              rule.name
+    assert_equal "aichi.jp",                rule.value
+    assert_equal %w(aichi jp).reverse,      rule.labels
+  end
+
+
+  def test_match
+    assert  @klass.new("*.uk").match?("google.uk")
+    assert  @klass.new("*.uk").match?("google.co.uk")
+    assert  @klass.new("*.co.uk").match?("google.co.uk")
+    assert !@klass.new("*.go.uk").match?("google.co.uk")
+  end
+
+  def test_length
+    assert_equal 2, @klass.new("*.uk").length
+    assert_equal 3, @klass.new("*.co.uk").length
+  end
+
+  def test_parts
+    assert_equal %w(uk), @klass.new("*.uk").parts
+    assert_equal %w(co uk), @klass.new("*.co.uk").parts
+  end
+
+  def test_decompose
+    assert_equal %w(google co.uk), @klass.new("*.uk").decompose("google.co.uk")
+    assert_equal %w(foo.google co.uk), @klass.new("*.uk").decompose("foo.google.co.uk")
+  end
+
+end

data/test/public_suffix_service_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+class PublicSuffixServiceTest < Test::Unit::TestCase
+
+  def test_self_parse_a_domain_with_tld_and_sld
+    domain = PublicSuffixService.parse("google.com")
+    assert_instance_of PublicSuffixService::Domain, domain
+    assert_equal "com",     domain.tld
+    assert_equal "google",  domain.sld
+    assert_equal nil,       domain.trd
+
+    domain = PublicSuffixService.parse("google.co.uk")
+    assert_instance_of PublicSuffixService::Domain, domain
+    assert_equal "co.uk",   domain.tld
+    assert_equal "google",  domain.sld
+    assert_equal nil,       domain.trd
+  end
+
+  def test_self_parse_a_domain_with_tld_and_sld_and_trd
+    domain = PublicSuffixService.parse("alpha.google.com")
+    assert_instance_of PublicSuffixService::Domain, domain
+    assert_equal "com",     domain.tld
+    assert_equal "google",  domain.sld
+    assert_equal "alpha",   domain.trd
+
+    domain = PublicSuffixService.parse("alpha.google.co.uk")
+    assert_instance_of PublicSuffixService::Domain, domain
+    assert_equal "co.uk",   domain.tld
+    assert_equal "google",  domain.sld
+    assert_equal "alpha",   domain.trd
+  end
+
+  def test_self_parse_a_domain_with_tld_and_sld_and_4rd
+    domain = PublicSuffixService.parse("one.two.google.com")
+    assert_instance_of PublicSuffixService::Domain, domain
+    assert_equal "com",     domain.tld
+    assert_equal "google",  domain.sld
+    assert_equal "one.two", domain.trd
+
+    domain = PublicSuffixService.parse("one.two.google.co.uk")
+    assert_instance_of PublicSuffixService::Domain, domain
+    assert_equal "co.uk",   domain.tld
+    assert_equal "google",  domain.sld
+    assert_equal "one.two", domain.trd
+  end
+
+  def test_self_parse_should_raise_with_invalid_domain
+    error = assert_raise(PublicSuffixService::InvalidDomain) { PublicSuffixService.parse("google.zip") }
+    assert_match %r{google\.zip}, error.message
+  end
+
+
+  def test_self_valid_question
+    assert  PublicSuffixService.valid?("google.com")
+    assert  PublicSuffixService.valid?("www.google.com")
+    assert  PublicSuffixService.valid?("google.co.uk")
+    assert  PublicSuffixService.valid?("www.google.co.uk")
+    assert !PublicSuffixService.valid?("google.zip")
+    assert !PublicSuffixService.valid?("www.google.zip")
+  end
+
+end