whois 4.0.6 → 6.0.3

data/spec/whois/server/adapters/formatted_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Whois::Server::Adapters::Formatted do
+  let(:definition) { [:tld, ".de", "whois.denic.de", { format: "-T dn,ace -C US-ASCII %s" }] }
+
+
+  describe "#lookup" do
+    it "returns the WHOIS record" do
+      response = "Whois Response"
+      expected = response
+      server = described_class.new(*definition)
+      expect(server.query_handler).to receive(:call).with("-T dn,ace -C US-ASCII domain.de", "whois.denic.de", 43).and_return(response)
+
+      record = server.lookup("domain.de")
+      expect(record.to_s).to eq(expected)
+      expect(record.parts).to eq([Whois::Record::Part.new(body: response, host: "whois.denic.de")])
+    end
+
+    context "without format option" do
+      it "raises an error" do
+        server = described_class.new(:tld, ".de", "whois.denic.de", {})
+        expect(server.query_handler).not_to receive(:call)
+
+        expect {
+          server.lookup("domain.de")
+        }.to raise_error(Whois::ServerError)
+      end
+    end
+
+    context "with port option" do
+      it "sends the request to given port" do
+        response = "Whois Response"
+        server = described_class.new(:tld, ".de", "whois.denic.de", { format: "-T dn,ace -C US-ASCII %s", port: 20 })
+        expect(server.query_handler).to receive(:call).with("-T dn,ace -C US-ASCII domain.de", "whois.denic.de", 20).and_return(response)
+
+        server.lookup("domain.de")
+      end
+    end
+
+    context "with bind option" do
+      it "binds the request to given host and port" do
+        response = "Whois Response"
+        server = described_class.new(:tld, ".de", "whois.denic.de", { format: "-T dn,ace -C US-ASCII %s" })
+        server.configure(bind_host: "192.168.1.1", bind_port: 3000)
+        expect(server.query_handler).to receive(:call).with("-T dn,ace -C US-ASCII domain.de", "whois.denic.de", 43, "192.168.1.1", 3000).and_return(response)
+
+        server.lookup("domain.de")
+      end
+    end
+  end
+end

data/spec/whois/server/adapters/none_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Whois::Server::Adapters::None do
+  describe "#lookup" do
+    it "raises Whois::NoInterfaceError" do
+      expect {
+        described_class.new(:tld, ".test", nil).lookup("example.test")
+      }.to raise_error(Whois::NoInterfaceError)
+    end
+
+    it "customizes the error message according to the type" do
+      expect {
+        described_class.new(:tld, ".test", nil).lookup("example.test")
+      }.to raise_error(Whois::NoInterfaceError, /tld/)
+
+      expect {
+        described_class.new(:ipv4, "127.0.0.1", nil).lookup("127.0.0.1")
+      }.to raise_error(Whois::NoInterfaceError, /ipv4/)
+    end
+  end
+end

data/spec/whois/server/adapters/not_implemented_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Whois::Server::Adapters::NotImplemented do
+  before do
+    @definition = [:ipv6, "2001:0000::/32", "teredo", { adapter: described_class }]
+  end
+
+
+  describe "#lookup" do
+    it "raises Whois::ServerNotImplemented" do
+      expect {
+        described_class.new(*@definition).lookup("example.test")
+      }.to raise_error(Whois::ServerNotImplemented)
+    end
+
+    it "customizes the error message according to the host" do
+      expect {
+        described_class.new(*@definition).lookup("example.test")
+      }.to raise_error(Whois::ServerNotImplemented, /teredo/)
+    end
+  end
+end

data/spec/whois/server/adapters/standard_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Whois::Server::Adapters::Standard do
+  let(:definition) { [:tld, ".test", "whois.test", {}] }
+
+
+  describe "#lookup" do
+    it "returns the WHOIS record" do
+      response = "Whois Response"
+      expected = response
+      server = described_class.new(*definition)
+      expect(server.query_handler).to receive(:call).with("domain.test", "whois.test", 43).and_return(response)
+
+      record = server.lookup("domain.test")
+      expect(record.to_s).to eq(expected)
+      expect(record.parts).to eq([Whois::Record::Part.new(body: response, host: "whois.test")])
+    end
+
+    context "with port option" do
+      it "sends the request to given port" do
+        response = "Whois Response"
+        server = described_class.new(:tld, ".test", "whois.test", { port: 20 })
+        expect(server.query_handler).to receive(:call).with("domain.test", "whois.test", 20).and_return(response)
+
+        server.lookup("domain.test")
+      end
+    end
+
+    context "with bind option" do
+      it "binds the request to given host and port" do
+        response = "Whois Response"
+        server = described_class.new(:tld, ".test", "whois.test", { port: 20 })
+        server.configure(bind_host: "192.168.1.100", bind_port: 3000)
+        expect(server.query_handler).to receive(:call).with("domain.test", "whois.test", 20, "192.168.1.100", 3000).and_return(response)
+
+        server.lookup("domain.test")
+      end
+    end
+  end
+end

data/spec/whois/server/adapters/verisign_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Whois::Server::Adapters::Verisign do
+  let(:definition) { [:tld, ".test", "whois.test", {}] }
+  let(:server) { described_class.new(*definition) }
+
+
+  describe "#lookup" do
+    context "without referral" do
+      it "returns the WHOIS record" do
+        response = "No match for example.test."
+        expected = response
+        expect(server.query_handler).to receive(:call).with("=example.test", "whois.test", 43).and_return(response)
+
+        record = server.lookup("example.test")
+        expect(record.to_s).to eq(expected)
+        expect(record.parts.size).to eq(1)
+        expect(record.parts).to eq([Whois::Record::Part.new(body: response, host: "whois.test")])
+      end
+    end
+
+    context "with referral" do
+      it "follows all referrals" do
+        referral = File.read(fixture("referrals/crsnic.com.txt"))
+        response = "Match for example.test."
+        expected = "#{referral}\n#{response}"
+        expect(server.query_handler).to receive(:call).with("=example.test", "whois.test", 43).and_return(referral)
+        expect(server.query_handler).to receive(:call).with("example.test", "whois.markmonitor.com", 43).and_return(response)
+
+        record = server.lookup("example.test")
+        expect(record.to_s).to eq(expected)
+        expect(record.parts.size).to eq(2)
+        expect(record.parts).to eq([Whois::Record::Part.new(body: referral, host: "whois.test"), Whois::Record::Part.new(body: response, host: "whois.markmonitor.com")])
+      end
+
+      it "ignores referral if options[:referral] is false" do
+        referral = File.read(fixture("referrals/crsnic.com.txt"))
+        server.options[:referral] = false
+        expect(server.query_handler).to receive(:call).with("=example.test", "whois.test", 43).and_return(referral)
+        expect(server.query_handler).not_to receive(:call)
+
+        record = server.lookup("example.test")
+        expect(record.parts.size).to eq(1)
+      end
+
+      # (see #103)
+      # This is the case of vrsn-20100925-dnssecmonitor86.net
+      it "ignores referral (gracefully) if missing" do
+        referral = File.read(fixture("referrals/crsnic.com_referral_missing.txt"))
+        expect(server.query_handler).to receive(:call).with("=example.test", "whois.test", 43).and_return(referral)
+        expect(server.query_handler).not_to receive(:call)
+
+        record = server.lookup("example.test")
+        expect(record.parts.size).to eq(1)
+      end
+    end
+  end
+end

data/spec/whois/server/adapters/web_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Whois::Server::Adapters::Web do
+  before do
+    @definition = [:tld, ".test", nil, { url: "http://whois.test" }]
+  end
+
+
+  describe "#lookup" do
+    it "raises Whois::WebInterfaceError" do
+      expect {
+        described_class.new(*@definition).lookup("example.test")
+      }.to raise_error(Whois::WebInterfaceError)
+    end
+
+    it "customizes the error message with the WHOIS web url" do
+      expect {
+        described_class.new(*@definition).lookup("example.test")
+      }.to raise_error(Whois::WebInterfaceError, /whois\.test/)
+    end
+  end
+end

data/spec/whois/server/socket_handler_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "whois/server/socket_handler"
+
+describe Whois::Server::SocketHandler do
+  describe "#call" do
+    [Errno::ECONNRESET, Errno::EHOSTUNREACH, Errno::ECONNREFUSED, Errno::ETIMEDOUT, Errno::EPIPE, SocketError].each do |error|
+      it "re-raises #{error} as Whois::ConnectionError" do
+        handler = described_class.new
+        expect(handler).to receive(:execute).and_raise(error)
+
+        expect {
+          handler.call("example.test", "whois.test", 43)
+        }.to raise_error(Whois::ConnectionError, "#{error}: #{error.new.message}")
+      end
+
+      it "executes a socket connection for given args" do
+        socket = instance_double(TCPSocket)
+        expect(socket).to receive(:write).with("example.test\r\n")
+        expect(socket).to receive(:read)
+        expect(socket).to receive(:close)
+
+        expect(TCPSocket).to receive(:new)
+          .with("whois.test", 43)
+          .and_return(socket)
+
+        handler = described_class.new
+        handler.call("example.test", "whois.test", 43)
+      end
+    end
+  end
+end

data/spec/whois/server_spec.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Whois::Server do
+  describe ".load_json" do
+    it "loads a definition from a JSON file" do
+      expect(File).to receive(:read).with("tld.json").and_return(<<~JSON)
+        {
+          "ae.org": {
+            "host": "whois.centralnic.com"
+          },
+          "ar.com": {
+            "host": "whois.centralnic.com"
+          }
+        }
+      JSON
+      with_definitions do
+        described_class.load_json("tld.json")
+        expect(described_class.definitions(:tld)).to eq([
+                                                          ["ae.org", "whois.centralnic.com", {}],
+                                                          ["ar.com", "whois.centralnic.com", {}],
+                                                        ])
+      end
+    end
+
+    it "convert option keys to Symbol" do
+      expect(File).to receive(:read).with("tld.json").and_return(<<~JSON)
+        {
+          "com": {
+            "host": "whois.crsnic.net",
+            "adapter": "verisign"
+          }
+        }
+      JSON
+      with_definitions do
+        described_class.load_json("tld.json")
+        expect(described_class.definitions(:tld)).to eq([
+                                                          ["com", "whois.crsnic.net", { adapter: "verisign" }],
+                                                        ])
+      end
+    end
+  end
+
+  describe ".definitions" do
+    it "returns the definitions array for given type" do
+      with_definitions do
+        described_class.define(Whois::Server::TYPE_TLD, "foo", "whois.foo")
+        definition = described_class.definitions(Whois::Server::TYPE_TLD)
+        expect(definition).to be_a(Array)
+        expect(definition).to eq([["foo", "whois.foo", {}]])
+      end
+    end
+
+    it "raises ArgumentError when the type is invalid" do
+      with_definitions do
+        expect {
+          described_class.definitions(:foo)
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe ".define" do
+    it "adds a new definition with given arguments" do
+      with_definitions do
+        described_class.define(Whois::Server::TYPE_TLD, "foo", "whois.foo")
+        expect(described_class.definitions(Whois::Server::TYPE_TLD)).to eq([["foo", "whois.foo", {}]])
+      end
+    end
+
+    it "accepts a hash of options" do
+      with_definitions do
+        described_class.define(Whois::Server::TYPE_TLD, "foo", "whois.foo", foo: "bar")
+        expect(described_class.definitions(Whois::Server::TYPE_TLD)).to eq([["foo", "whois.foo", { foo: "bar" }]])
+      end
+    end
+  end
+
+  describe ".factory" do
+    it "returns an adapter initialized with given arguments" do
+      server = described_class.factory(:tld, "test", "whois.test")
+      expect(server.type).to eq(:tld)
+      expect(server.allocation).to eq("test")
+      expect(server.host).to eq("whois.test")
+      expect(server.options).to eq({})
+    end
+
+    it "returns a standard adapter by default" do
+      server = described_class.factory(:tld, "test", "whois.test")
+      expect(server).to be_a(Whois::Server::Adapters::Standard)
+    end
+
+    it "accepts an :adapter option as Class and returns an instance of given adapter" do
+      a = Class.new do
+        attr_reader :args
+
+        def initialize(*args)
+          @args = args
+        end
+      end
+      server = described_class.factory(:tld, "test", "whois.test", adapter: a)
+      expect(server).to be_a(a)
+      expect(server.args).to eq([:tld, "test", "whois.test", {}])
+    end
+
+    it "accepts an :adapter option as Symbol or String, load Class and returns an instance of given adapter" do
+      server = described_class.factory(:tld, "test", "whois.test", adapter: :none)
+      expect(server).to be_a(Whois::Server::Adapters::None)
+      server = described_class.factory(:tld, "test", "whois.test", adapter: "none")
+      expect(server).to be_a(Whois::Server::Adapters::None)
+    end
+
+    it "deletes the adapter option" do
+      server = described_class.factory(:tld, "test", "whois.test", adapter: Whois::Server::Adapters::None, foo: "bar")
+      expect(server.options).to eq({ foo: "bar" })
+    end
+  end
+
+  describe ".guess" do
+    it "recognizes tld" do
+      server = described_class.guess(".com")
+      expect(server).to be_a(Whois::Server::Adapters::Base)
+      expect(server.type).to eq(Whois::Server::TYPE_TLD)
+    end
+
+    it "recognizes domain" do
+      server = described_class.guess("example.com")
+      expect(server).to be_a(Whois::Server::Adapters::Base)
+      expect(server.type).to eq(Whois::Server::TYPE_TLD)
+    end
+
+    it "recognizes ipv4" do
+      server = described_class.guess("127.0.0.1")
+      expect(server).to be_a(Whois::Server::Adapters::Base)
+      expect(server.type).to eq(Whois::Server::TYPE_IPV4)
+    end
+
+    it "recognizes ipv6" do
+      server = described_class.guess("2001:0db8:85a3:0000:0000:8a2e:0370:7334")
+      expect(server).to be_a(Whois::Server::Adapters::Base)
+      expect(server.type).to eq(Whois::Server::TYPE_IPV6)
+    end
+
+    it "recognizes ipv6 when zero groups" do
+      server = described_class.guess("2002::1")
+      expect(server).to be_a(Whois::Server::Adapters::Base)
+      expect(server.type).to eq(Whois::Server::TYPE_IPV6)
+    end
+
+    it "recognizes asn16" do
+      server = described_class.guess("AS23456")
+      expect(server).to be_a(Whois::Server::Adapters::Base)
+      expect(server.type).to eq(Whois::Server::TYPE_ASN16)
+    end
+
+    it "recognizes asn32" do
+      server = described_class.guess("AS131072")
+      expect(server).to be_a(Whois::Server::Adapters::Base)
+      expect(server.type).to eq(Whois::Server::TYPE_ASN32)
+    end
+
+    it "recognizes email" do
+      expect {
+        described_class.guess("email@example.org")
+      }.to raise_error(Whois::ServerNotSupported, /email/)
+    end
+
+    it "raises when unrecognized value" do
+      expect {
+        described_class.guess("invalid")
+      }.to raise_error(Whois::ServerNotFound)
+    end
+
+
+    context "when the input is a tld" do
+      it "returns a IANA adapter" do
+        expect(described_class.guess(".com")).to eq(described_class.factory(:tld, ".", "whois.iana.org"))
+      end
+
+      it "returns a IANA adapter when the input is an idn" do
+        expect(described_class.guess(".xn--fiqs8s")).to eq(described_class.factory(:tld, ".", "whois.iana.org"))
+      end
+    end
+
+    context "when the input is a domain" do
+      it "lookups definitions and returns the adapter" do
+        with_definitions do
+          described_class.define(:tld, "test", "whois.test")
+          expect(described_class.guess("example.test")).to eq(described_class.factory(:tld, "test", "whois.test"))
+        end
+      end
+
+      it "doesn't consider the dot as a regexp pattern" do
+        with_definitions do
+          described_class.define(:tld, "no.com", "whois.no.com")
+          described_class.define(:tld, "com", "whois.com")
+          expect(described_class.guess("antoniocangiano.com")).to eq(described_class.factory(:tld, "com", "whois.com"))
+        end
+      end
+
+      it "returns the closer definition" do
+        with_definitions do
+          described_class.define(:tld, "com", com = "whois.com")
+          described_class.define(:tld, "com.foo", comfoo = "whois.com.foo")
+          described_class.define(:tld, "foo.com", foocom = "whois.foo.com")
+
+          expect(described_class.guess("example.com").host).to eq(com)
+          expect(described_class.guess("example.com.foo").host).to eq(comfoo)
+          expect(described_class.guess("example.foo.com").host).to eq(foocom)
+        end
+      end
+    end
+
+    context "when the input is an asn16" do
+      it "lookups definitions and returns the adapter" do
+        with_definitions do
+          described_class.define(:asn16, "0 65535", "whois.test")
+          expect(described_class.guess("AS65535")).to eq(described_class.factory(:asn16, "0 65535", "whois.test"))
+        end
+      end
+
+      it "raises if definition is not found" do
+        with_definitions do
+          described_class.define(:asn16, "0 60000", "whois.test")
+          expect {
+            described_class.guess("AS65535")
+          }.to raise_error(Whois::AllocationUnknown)
+        end
+      end
+    end
+
+    context "when the input is an asn32" do
+      it "lookups definitions and returns the adapter" do
+        with_definitions do
+          described_class.define(:asn32, "65536 394239", "whois.test")
+          expect(described_class.guess("AS65536")).to eq(described_class.factory(:asn32, "65536 394239", "whois.test"))
+        end
+      end
+
+      it "raises if definition is not found" do
+        with_definitions do
+          described_class.define(:asn32, "65536 131071", "whois.test")
+          expect {
+            described_class.guess("AS200000")
+          }.to raise_error(Whois::AllocationUnknown)
+        end
+      end
+    end
+
+    context "when the input is a ipv4" do
+      it "lookups definitions and returns the adapter" do
+        with_definitions do
+          described_class.define(:ipv4, "192.168.1.0/10", "whois.test")
+          expect(described_class.find_for_ip("192.168.1.1")).to eq(described_class.factory(:ipv4, "192.168.1.0/10", "whois.test"))
+        end
+      end
+
+      it "raises if definition is not found" do
+        with_definitions do
+          described_class.define(:ipv4, "192.168.1.0/10", "whois.test")
+          expect {
+            described_class.guess("192.192.0.1")
+          }.to raise_error(Whois::AllocationUnknown)
+        end
+      end
+    end
+
+    context "when the input is a ipv6" do
+      it "lookups definitions and returns the adapter" do
+        with_definitions do
+          described_class.define(:ipv6, "2001:0200::/23", "whois.test")
+          expect(described_class.guess("2001:0200::1")).to eq(described_class.factory(:ipv6, "2001:0200::/23", "whois.test"))
+        end
+      end
+
+      it "raises if definition is not found" do
+        with_definitions do
+          described_class.define(:ipv6, "::1", "whois.test")
+          expect {
+            described_class.guess("2002:0300::1")
+          }.to raise_error(Whois::AllocationUnknown)
+        end
+      end
+
+      it "recognizes ipv4 compatibility mode" do
+        with_definitions do
+          described_class.define(:ipv6, "::192.168.1.1", "whois.test")
+          expect(described_class.guess("::192.168.1.1")).to eq(described_class.factory(:ipv6, "::192.168.1.1", "whois.test"))
+        end
+      end
+
+      it "rescues IPAddr ArgumentError", issue: "weppos/whois#174" do
+        with_definitions do
+          expect {
+            described_class.guess("f53")
+          }.to raise_error(Whois::AllocationUnknown)
+        end
+      end
+    end
+  end
+end

data/spec/whois/web_interface_error_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Whois::WebInterfaceError do
+  describe "#initialize" do
+    it "sets the URL" do
+      expect(described_class.new("http://example.com").url).to eq("http://example.com")
+    end
+
+    it "requires the URL argument" do
+      expect do
+        described_class.new
+      end.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#message" do
+    it "interpolates the URL" do
+      expect(described_class.new("http://example.com").message).to match(%r{http://example.com})
+    end
+  end
+end

data/spec/whois/whois_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Whois do
+  describe ".lookup" do
+    it "delegates the lookup to a new client" do
+      client = double
+      expect(client).to receive(:lookup).with("example.com").and_return(:result)
+      expect(Whois::Client).to receive(:new).and_return(client)
+
+      expect(described_class.lookup("example.com")).to eq(:result)
+    end
+  end
+end

data/utils/compare-whois.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby -wKU
+
+$:.unshift(File.expand_path("../../lib", __FILE__))
+
+require 'whois'
+
+IANAWHOIS_DIR = "~/Code/ianawhois"
+
+servers     = {}
+definitions = Whois::Server.definitions(:tld).inject({}) do |hash, item|
+  hash.merge(item[0] => item[1])
+end
+
+Dir.glob("#{File.expand_path(IANAWHOIS_DIR)}/*").each do |entry|
+  basename = File.basename(entry)
+  next unless basename.match?(/^[A-Z]+$/)
+  content = File.read(entry)
+  server  = content =~ /^whois:\s+(.+)\n$/ && $1
+  servers[".#{basename.downcase}"] = server
+end
+
+diffs = []
+servers.each do |host, server|
+  iana, whois = server, definitions[host]
+  if iana != whois
+    diffs << "#{host}: #{whois.inspect} -> #{iana.inspect}"
+  end
+end
+
+puts diffs.join("\n")