wallee-ruby-sdk 3.0.5 → 3.1.2

data/vendor/bundle/ruby/2.4.0/gems/public_suffix-4.0.7/test/tests.txt

@@ -0,0 +1,98 @@
+// Any copyright is dedicated to the Public Domain.
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+// null input
+null, null
+// Mixed case
+'COM', null
+'example.COM', 'example.com'
+'WwW.example.COM', 'example.com'
+// Leading dot
+'.com', null
+'.example', null
+'.example.com', null
+'.example.example', null
+// Unlisted TLD
+'example', null
+'example.example', 'example.example'
+'b.example.example', 'example.example'
+'a.b.example.example', 'example.example'
+// Listed, but non-Internet, TLD
+//'local', null
+//'example.local', null
+//'b.example.local', null
+//'a.b.example.local', null
+// TLD with only 1 rule
+'biz', null
+'domain.biz', 'domain.biz'
+'b.domain.biz', 'domain.biz'
+'a.b.domain.biz', 'domain.biz'
+// TLD with some 2-level rules
+'com', null
+'example.com', 'example.com'
+'b.example.com', 'example.com'
+'a.b.example.com', 'example.com'
+'uk.com', null
+'example.uk.com', 'example.uk.com'
+'b.example.uk.com', 'example.uk.com'
+'a.b.example.uk.com', 'example.uk.com'
+'test.ac', 'test.ac'
+// TLD with only 1 (wildcard) rule
+'mm', null
+'c.mm', null
+'b.c.mm', 'b.c.mm'
+'a.b.c.mm', 'b.c.mm'
+// More complex TLD
+'jp', null
+'test.jp', 'test.jp'
+'www.test.jp', 'test.jp'
+'ac.jp', null
+'test.ac.jp', 'test.ac.jp'
+'www.test.ac.jp', 'test.ac.jp'
+'kyoto.jp', null
+'test.kyoto.jp', 'test.kyoto.jp'
+'ide.kyoto.jp', null
+'b.ide.kyoto.jp', 'b.ide.kyoto.jp'
+'a.b.ide.kyoto.jp', 'b.ide.kyoto.jp'
+'c.kobe.jp', null
+'b.c.kobe.jp', 'b.c.kobe.jp'
+'a.b.c.kobe.jp', 'b.c.kobe.jp'
+'city.kobe.jp', 'city.kobe.jp'
+'www.city.kobe.jp', 'city.kobe.jp'
+// TLD with a wildcard rule and exceptions
+'ck', null
+'test.ck', null
+'b.test.ck', 'b.test.ck'
+'a.b.test.ck', 'b.test.ck'
+'www.ck', 'www.ck'
+'www.www.ck', 'www.ck'
+// US K12
+'us', null
+'test.us', 'test.us'
+'www.test.us', 'test.us'
+'ak.us', null
+'test.ak.us', 'test.ak.us'
+'www.test.ak.us', 'test.ak.us'
+'k12.ak.us', null
+'test.k12.ak.us', 'test.k12.ak.us'
+'www.test.k12.ak.us', 'test.k12.ak.us'
+// IDN labels
+'食狮.com.cn', '食狮.com.cn'
+'食狮.公司.cn', '食狮.公司.cn'
+'www.食狮.公司.cn', '食狮.公司.cn'
+'shishi.公司.cn', 'shishi.公司.cn'
+'公司.cn', null
+'食狮.中国', '食狮.中国'
+'www.食狮.中国', '食狮.中国'
+'shishi.中国', 'shishi.中国'
+'中国', null
+// Same as above, but punycoded
+'xn--85x722f.com.cn', 'xn--85x722f.com.cn'
+'xn--85x722f.xn--55qx5d.cn', 'xn--85x722f.xn--55qx5d.cn'
+'www.xn--85x722f.xn--55qx5d.cn', 'xn--85x722f.xn--55qx5d.cn'
+'shishi.xn--55qx5d.cn', 'shishi.xn--55qx5d.cn'
+'xn--55qx5d.cn', null
+'xn--85x722f.xn--fiqs8s', 'xn--85x722f.xn--fiqs8s'
+'www.xn--85x722f.xn--fiqs8s', 'xn--85x722f.xn--fiqs8s'
+'shishi.xn--fiqs8s', 'shishi.xn--fiqs8s'
+'xn--fiqs8s', null

data/vendor/bundle/ruby/2.4.0/gems/public_suffix-4.0.7/test/unit/domain_test.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class PublicSuffix::DomainTest < Minitest::Test
+
+  def setup
+    @klass = PublicSuffix::Domain
+  end
+
+  # Tokenizes given input into labels.
+  def test_self_name_to_labels
+    assert_equal  %w( someone spaces live com ),
+                  PublicSuffix::Domain.name_to_labels("someone.spaces.live.com")
+    assert_equal  %w( leontina23samiko wiki zoho com ),
+                  PublicSuffix::Domain.name_to_labels("leontina23samiko.wiki.zoho.com")
+  end
+
+  # Converts input into String.
+  def test_self_name_to_labels_converts_input_to_string
+    assert_equal  %w( someone spaces live com ),
+                  PublicSuffix::Domain.name_to_labels(:"someone.spaces.live.com")
+  end
+
+
+  def test_initialize_with_tld
+    domain = @klass.new("com")
+    assert_equal "com", domain.tld
+    assert_nil domain.sld
+    assert_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_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_nil @klass.new("com").domain
+    assert_nil @klass.new("tldnotlisted").domain
+    assert_equal "google.com", @klass.new("com", "google").domain
+    assert_equal "google.tldnotlisted", @klass.new("tldnotlisted", "google").domain
+    assert_equal "google.com", @klass.new("com", "google", "www").domain
+    assert_equal "google.tldnotlisted", @klass.new("tldnotlisted", "google", "www").domain
+  end
+
+  def test_subdomain
+    assert_nil @klass.new("com").subdomain
+    assert_nil @klass.new("tldnotlisted").subdomain
+    assert_nil @klass.new("com", "google").subdomain
+    assert_nil @klass.new("tldnotlisted", "google").subdomain
+    assert_equal "www.google.com", @klass.new("com", "google", "www").subdomain
+    assert_equal "www.google.tldnotlisted", @klass.new("tldnotlisted", "google", "www").subdomain
+  end
+
+
+  def test_domain_question
+    assert !@klass.new("com").domain?
+    assert  @klass.new("com", "example").domain?
+    assert  @klass.new("com", "example", "www").domain?
+    assert  @klass.new("tldnotlisted", "example").domain?
+  end
+
+end

data/vendor/bundle/ruby/2.4.0/gems/public_suffix-4.0.7/test/unit/errors_test.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ErrorsTest < Minitest::Test
+
+  # 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/vendor/bundle/ruby/2.4.0/gems/public_suffix-4.0.7/test/unit/list_test.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class PublicSuffix::ListTest < Minitest::Test
+
+  def setup
+    @list = PublicSuffix::List.new
+  end
+
+  def teardown
+    PublicSuffix::List.default = nil
+  end
+
+
+  def test_initialize
+    assert_instance_of PublicSuffix::List, @list
+    assert_equal 0, @list.size
+  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_each_without_block
+    list = PublicSuffix::List.parse(<<LIST)
+alpha
+beta
+LIST
+
+    assert_kind_of Enumerator, list.each
+    assert_equal 2, list.each.count
+    assert_equal PublicSuffix::Rule.factory("alpha"), list.each.first
+  end
+
+  def test_each_with_block
+    list = PublicSuffix::List.parse(<<LIST)
+alpha
+beta
+LIST
+
+    entries = []
+    list.each { |r| entries << r }
+
+    assert_equal 2, entries.count
+    assert_equal PublicSuffix::Rule.factory("alpha"), entries.first
+  end
+
+
+  def test_add
+    assert_equal @list, @list.add(PublicSuffix::Rule.factory("foo"))
+    assert_equal @list, @list <<  PublicSuffix::Rule.factory("bar")
+    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 @list.default_rule, @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.size
+    assert_equal @list, @list.add(PublicSuffix::Rule.factory(""))
+    assert_equal 1, @list.size
+  end
+
+  def test_clear
+    assert_equal 0, @list.size
+    assert_equal @list, @list.add(PublicSuffix::Rule.factory(""))
+    assert_equal 1, @list.size
+    assert_equal @list, @list.clear
+    assert_equal 0, @list.size
+  end
+
+
+  def test_find
+    list = PublicSuffix::List.parse(<<LIST)
+// 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===
+LIST
+
+    # 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.send(:select, "british-library.uk").size
+  end
+
+  def test_select_name_blank
+    assert_equal [], list.send(:select, nil)
+    assert_equal [], list.send(:select, "")
+    assert_equal [], list.send(:select, " ")
+  end
+
+  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.send(:select, "foo.io"), [r1]
+    assert_equal list.send(:select, "example.io"), [r1, r2]
+    assert_equal list.send(:select, "foo.example.io"), [r1, r2]
+
+    assert_equal list.send(:select, "foo.io", ignore_private: false), [r1]
+    assert_equal list.send(:select, "example.io", ignore_private: false), [r1, r2]
+    assert_equal list.send(:select, "foo.example.io", ignore_private: false), [r1, r2]
+
+    assert_equal list.send(:select, "foo.io", ignore_private: true), [r1]
+    assert_equal list.send(:select, "example.io", ignore_private: true), [r1]
+    assert_equal list.send(:select, "foo.example.io", ignore_private: true), [r1]
+  end
+
+
+  def test_self_default_getter
+    PublicSuffix::List.default = nil
+    assert_nil(PublicSuffix::List.class_eval { @default })
+    PublicSuffix::List.default
+    refute_nil(PublicSuffix::List.class_eval { @default })
+  end
+
+  def test_self_default_setter
+    PublicSuffix::List.default
+    refute_nil(PublicSuffix::List.class_eval { @default })
+    PublicSuffix::List.default = nil
+    assert_nil(PublicSuffix::List.class_eval { @default })
+  end
+
+  def test_self_parse
+    list = PublicSuffix::List.parse(<<LIST)
+// 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===
+LIST
+
+    assert_instance_of PublicSuffix::List, list
+    assert_equal 4, list.size
+
+    rules = %w( com *.uk !british-library.uk blogspot.com ).map { |name| PublicSuffix::Rule.factory(name) }
+    assert_equal rules, list.each.to_a
+
+    # private domains
+    assert_equal false, list.find("com").private
+    assert_equal true,  list.find("blogspot.com").private
+  end
+
+
+  private
+
+  def list
+    @_list ||= PublicSuffix::List.parse(<<LIST)
+// com : http://en.wikipedia.org/wiki/.com
+com
+
+// uk : http://en.wikipedia.org/wiki/.uk
+*.uk
+*.sch.uk
+!bl.uk
+!british-library.uk
+LIST
+  end
+
+end

data/vendor/bundle/ruby/2.4.0/gems/public_suffix-4.0.7/test/unit/public_suffix_test.rb

@@ -0,0 +1,188 @@
+# 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