whois 4.0.6 → 6.0.3

data/spec/whois/client_spec.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Whois::Client do
+  describe "#initialize" do
+    it "accepts a zero parameters" do
+      expect { described_class.new }.not_to raise_error
+    end
+
+    it "accepts a settings parameter" do
+      expect { described_class.new({ foo: "bar" }) }.not_to raise_error
+    end
+
+
+    it "accepts a timeout setting with a value in seconds" do
+      client = described_class.new(timeout: 100)
+      expect(client.timeout).to eq(100)
+    end
+
+    it "accepts a timeout setting with a nil value" do
+      client = described_class.new(timeout: nil)
+      expect(client.timeout).to be_nil
+    end
+
+    it "accepts a block" do
+      described_class.new do |client|
+        expect(client).to be_instance_of(described_class)
+      end
+    end
+
+
+    it "defaults timeout setting to DEFAULT_TIMEOUT" do
+      client = described_class.new
+      expect(client.timeout).to eq(described_class::DEFAULT_TIMEOUT)
+    end
+
+    it "sets settings to given argument, except timeout" do
+      client = described_class.new(timeout: nil, foo: "bar")
+      expect(client.settings).to eq({ foo: "bar" })
+    end
+  end
+
+  describe "#lookup" do
+    it "converts the argument to string" do
+      query = ["example", ".", "test"]
+      query.instance_eval do
+        def to_s
+          join
+        end
+      end
+
+      server = Whois::Server::Adapters::Base.new(:tld, "test", "whois.test")
+      expect(server).to receive(:lookup).with("example.test")
+      expect(Whois::Server).to receive(:guess).with("example.test").and_return(server)
+
+      described_class.new.lookup(query)
+    end
+
+    it "converts the argument to downcase" do
+      server = Whois::Server::Adapters::Base.new(:tld, "test", "whois.test")
+      expect(server).to receive(:lookup).with("example.test")
+      expect(Whois::Server).to receive(:guess).with("example.test").and_return(server)
+
+      described_class.new.lookup("Example.TEST")
+    end
+
+    it "detects email" do
+      expect {
+        described_class.new.lookup("weppos@weppos.net")
+      }.to raise_error(Whois::ServerNotSupported)
+    end
+
+    it "works with domain with no whois" do
+      Whois::Server.define(:tld, "nowhois", nil, adapter: Whois::Server::Adapters::None)
+
+      expect {
+        described_class.new.lookup("domain.nowhois")
+      }.to raise_error(Whois::NoInterfaceError, /no whois server/)
+    end
+
+    it "works with domain with web whois" do
+      Whois::Server.define(:tld, "webwhois", nil, adapter: Whois::Server::Adapters::Web, url: "http://www.example.com/")
+
+      expect {
+        described_class.new.lookup("domain.webwhois")
+      }.to raise_error(Whois::WebInterfaceError, /www\.example\.com/)
+    end
+
+    it "raises if timeout is exceeded" do
+      adapter = Class.new(Whois::Server::Adapters::Base) do
+        def lookup(*)
+          sleep(2)
+        end
+      end
+      expect(Whois::Server).to receive(:guess).and_return(adapter.new(:tld, "test", "whois.test"))
+
+      client = described_class.new(timeout: 1)
+      expect {
+        client.lookup("example.test")
+      }.to raise_error(Timeout::Error)
+    end
+
+    it "does not raise if timeout is not exceeded" do
+      adapter = Class.new(Whois::Server::Adapters::Base) do
+        def lookup(*)
+          sleep(1)
+        end
+      end
+      expect(Whois::Server).to receive(:guess).and_return(adapter.new(:tld, "test", "whois.test"))
+
+      client = described_class.new(timeout: 5)
+      expect {
+        client.lookup("example.test")
+      }.not_to raise_error
+    end
+
+    it "supports unlimited timeout" do
+      adapter = Class.new(Whois::Server::Adapters::Base) do
+        def lookup(*)
+          sleep(1)
+        end
+      end
+      expect(Whois::Server).to receive(:guess).and_return(adapter.new(:tld, "test", "whois.test"))
+
+      client = described_class.new.tap { |c| c.timeout = nil }
+      expect {
+        client.lookup("example.test")
+      }.not_to raise_error
+    end
+  end
+
+  # FIXME: use RSpec metadata
+  need_connectivity do
+    describe "#query" do
+      it "sends a query for given domain" do
+        record = described_class.new.lookup("weppos.it")
+        expect(record.match?(/Domain:\s+weppos\.it/)).to be(true)
+        expect(record.match?(/Created:/)).to be(true)
+      end
+    end
+  end
+end

data/spec/whois/record/part_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Whois::Record::Part do
+  describe "#initialize" do
+    it "accepts an empty value" do
+      expect {
+        instance = described_class.new
+        expect(instance.body).to be_nil
+      }.not_to raise_error
+    end
+
+    it "accepts an empty hash" do
+      expect {
+        instance = described_class.new({})
+        expect(instance.body).to be_nil
+      }.not_to raise_error
+    end
+
+    it "initializes a new instance from given hash" do
+      instance = described_class.new(body: "This is a WHOIS record.", host: "whois.example.test")
+
+      expect(instance.body).to eq("This is a WHOIS record.")
+      expect(instance.host).to eq("whois.example.test")
+    end
+
+    it "initializes a new instance from given block" do
+      instance = described_class.new do |c|
+        c.body  = "This is a WHOIS record."
+        c.host  = "whois.example.test"
+      end
+
+      expect(instance.body).to eq("This is a WHOIS record.")
+      expect(instance.host).to eq("whois.example.test")
+    end
+  end
+end

data/spec/whois/record_spec.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Whois::Record do
+  subject { described_class.new(server, parts) }
+
+  let(:server) {
+    Whois::Server.factory(:tld, ".foo", "whois.example.test")
+  }
+  let(:parts) {
+    [
+      Whois::Record::Part.new(body: "This is a record from foo.", host: "foo.example.test"),
+      Whois::Record::Part.new(body: "This is a record from bar.", host: "bar.example.test"),
+    ]
+  }
+  let(:content) {
+    parts.map(&:body).join("\n")
+  }
+
+
+  describe "#initialize" do
+    it "requires a server and parts" do
+      expect { described_class.new }.to raise_error(ArgumentError)
+      expect { described_class.new(server) }.to raise_error(ArgumentError)
+      expect { described_class.new(server, parts) }.not_to raise_error
+    end
+
+    it "sets server and parts from arguments" do
+      instance = described_class.new(server, parts)
+      expect(instance.server).to be(server)
+      expect(instance.parts).to be(parts)
+
+      instance = described_class.new(nil, nil)
+      expect(instance.server).to be_nil
+      expect(instance.parts).to be_nil
+    end
+  end
+
+
+  describe "#to_s" do
+    it "delegates to #content" do
+      expect(described_class.new(nil, [parts[0]]).to_s).to eq(parts[0].body)
+      expect(described_class.new(nil, parts).to_s).to eq(parts.map(&:body).join("\n"))
+      expect(described_class.new(nil, []).to_s).to eq("")
+    end
+  end
+
+  describe "#inspect" do
+    it "inspects the record content" do
+      expect(described_class.new(nil, [parts[0]]).inspect).to eq(parts[0].body.inspect)
+    end
+
+    it "joins multiple parts" do
+      expect(described_class.new(nil, parts).inspect).to eq(parts.map(&:body).join("\n").inspect)
+    end
+
+    it "joins empty parts" do
+      expect(described_class.new(nil, []).inspect).to eq("".inspect)
+    end
+  end
+
+  describe "#==" do
+    it "returns true when other is the same instance" do
+      one = two = described_class.new(server, parts)
+
+      expect(one == two).to be_truthy
+      expect(one).to eql(two)
+    end
+
+    it "returns true when other has same class and has the same parts" do
+      one = described_class.new(server, parts)
+      two = described_class.new(server, parts)
+
+      expect(one == two).to be_truthy
+      expect(one).to eql(two)
+    end
+
+    it "returns true when other has descendant class and has the same parts" do
+      subklass = Class.new(described_class)
+      one = described_class.new(server, parts)
+      two = subklass.new(server, parts)
+
+      expect(one == two).to be_truthy
+      expect(one).to eql(two)
+    end
+
+    it "returns true when other has same class and has equal parts" do
+      one = described_class.new(server, parts)
+      two = described_class.new(server, parts.dup)
+
+      expect(one == two).to be_truthy
+      expect(one).to eql(two)
+    end
+
+    it "returns true when other has same class, different server and the same parts" do
+      one = described_class.new(server, parts)
+      two = described_class.new(nil, parts)
+
+      expect(one == two).to be_truthy
+      expect(one).to eql(two)
+    end
+
+    it "returns false when other has different class and has the same parts" do
+      one = described_class.new(server, parts)
+      two = Struct.new(:server, :parts).new(server, parts)
+
+      expect(one == two).to be_falsey
+      expect(one).not_to eql(two)
+    end
+
+    it "returns false when other has different parts" do
+      one = described_class.new(server, parts)
+      two = described_class.new(server, [])
+
+      expect(one == two).to be_falsey
+      expect(one).not_to eql(two)
+    end
+
+    it "returns false when other is string and has the same content" do
+      one = described_class.new(server, parts)
+      two = described_class.new(server, parts).to_s
+
+      expect(one == two).to be_falsey
+      expect(one).not_to eql(two)
+    end
+
+    it "returns false when other is string and has different content" do
+      one = described_class.new(server, parts)
+      two = "different"
+
+      expect(one == two).to be_falsey
+      expect(one).not_to eql(two)
+    end
+  end
+
+
+  describe "#match" do
+    it "delegates to content" do
+      expect(subject.match(/record/)).to be_a(MatchData)
+      expect(subject.match(/record/)[0]).to eq("record")
+
+      expect(subject.match(/nomatch/)).to be_nil
+    end
+  end
+
+  describe "#match?" do
+    it "calls match and checks for match" do
+      expect(subject.match?(/record/)).to be(true)
+      expect(subject.match?(/nomatch/)).to be(false)
+    end
+  end
+
+
+  describe "#content" do
+    it "returns the part body" do
+      expect(described_class.new(nil, [parts[0]]).content).to eq(parts[0].body)
+    end
+
+    it "joins multiple parts" do
+      expect(described_class.new(nil, parts).content).to eq(parts.map(&:body).join("\n"))
+    end
+
+    it "returns an empty string when no parts" do
+      expect(described_class.new(nil, []).content).to eq("")
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Whois::Server::Adapters::Afilias do
+  let(:definition) { [:tld, ".test", "whois.afilias-grs.info", {}] }
+  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.afilias-grs.info", 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.afilias-grs.info")])
+      end
+    end
+
+    context "with referral" do
+      it "follows all referrals" do
+        referral = File.read(fixture("referrals/afilias.bz.txt"))
+        response = "Match for example.test."
+        expected = "#{referral}\n#{response}"
+        expect(server.query_handler).to receive(:call).with("example.test", "whois.afilias-grs.info", 43).and_return(referral)
+        expect(server.query_handler).to receive(:call).with("example.test", "whois.belizenic.bz", 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.afilias-grs.info"), Whois::Record::Part.new(body: response, host: "whois.belizenic.bz")])
+      end
+
+      it "ignores referral if options[:referral] is false" do
+        referral = File.read(fixture("referrals/afilias.bz.txt"))
+        server.options[:referral] = false
+        expect(server.query_handler).to receive(:call).with("example.test", "whois.afilias-grs.info", 43).and_return(referral)
+        expect(server.query_handler).not_to receive(:call).with("example.test", "whois.belizenic.bz", 43)
+
+        record = server.lookup("example.test")
+        expect(record.parts.size).to eq(1)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Whois::Server::Adapters::Arin do
+  let(:definition) { [:ipv4, "0.0.0.0/1", "whois.arin.net"] }
+  let(:server) { described_class.new(*definition) }
+
+  describe "#lookup" do
+    context "without referral" do
+      it "returns the WHOIS record" do
+        response = "Whois Response"
+        expected = response
+        expect(server.query_handler).to receive(:call).with("n + 0.0.0.0", "whois.arin.net", 43).and_return(response)
+        record = server.lookup("0.0.0.0")
+        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.arin.net")])
+      end
+    end
+
+    context "with referral" do
+      it "follows whois:// referrals" do
+        referral = File.read(fixture("referrals/arin_referral_whois.txt"))
+        response = "Whois Response"
+        expected = "#{referral}\n#{response}"
+        expect(server.query_handler).to receive(:call).with("n + 0.0.0.0", "whois.arin.net", 43).and_return(referral)
+        expect(server.query_handler).to receive(:call).with("0.0.0.0", "whois.ripe.net", 43).and_return(response)
+
+        record = server.lookup("0.0.0.0")
+        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.arin.net"),
+                                    Whois::Record::Part.new(body: response, host: "whois.ripe.net"),])
+      end
+
+      it "follows rwhois:// referrals" do
+        referral = File.read(fixture("referrals/arin_referral_rwhois.txt"))
+        response = "Whois Response"
+        expected = "#{referral}\n#{response}"
+        expect(server.query_handler).to receive(:call).with("n + 0.0.0.0", "whois.arin.net", 43).and_return(referral)
+        expect(server.query_handler).to receive(:call).with("0.0.0.0", "rwhois.servernap.net", 4321).and_return(response)
+
+        record = server.lookup("0.0.0.0")
+        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.arin.net"),
+                                    Whois::Record::Part.new(body: response, host: "rwhois.servernap.net"),])
+      end
+
+      it "ignores referral if options[:referral] is false" do
+        referral = File.read(fixture("referrals/arin_referral_whois.txt"))
+        server.options[:referral] = false
+        expect(server.query_handler).to receive(:call).with("n + 0.0.0.0", "whois.arin.net", 43).and_return(referral)
+        expect(server.query_handler).not_to receive(:call).with("0.0.0.0", "whois.ripe.net", 43)
+
+        record = server.lookup("0.0.0.0")
+        expect(record.parts.size).to eq(1)
+      end
+
+      it "ignores referral (gracefully) if missing" do
+        referral = File.read(fixture("referrals/arin_referral_missing.txt"))
+        expect(server.query_handler).to receive(:call).with("n + 0.0.0.0", "whois.arin.net", 43).and_return(referral)
+        expect(server.query_handler).not_to receive(:call)
+
+        record = server.lookup("0.0.0.0")
+        expect(record.parts.size).to eq(1)
+      end
+
+      it "folows referrals without ports" do
+        referral = File.read(fixture("referrals/arin_referral_apnic.txt"))
+        response = "Whois Response"
+        expect(server.query_handler).to receive(:call).with("n + 0.0.0.0", "whois.arin.net", 43).and_return(referral)
+        expect(server.query_handler).to receive(:call).with("0.0.0.0", "whois.apnic.net", 43).and_return(response)
+
+        record = server.lookup("0.0.0.0")
+        expect(record.parts.size).to eq(2)
+        expect(record.parts).to eq([Whois::Record::Part.new(body: referral, host: "whois.arin.net"),
+                                    Whois::Record::Part.new(body: response, host: "whois.apnic.net"),])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "whois/server/adapters/arin"
+
+describe Whois::Server::Adapters::Arpa do
+  let(:definition) { [:tld, ".in-addr.arpa", nil, {}] }
+
+  describe "#lookup" do
+    it "returns the WHOIS record" do
+      server = described_class.new(*definition)
+      expect(Whois::Server::Adapters::Arin.query_handler).to receive(:call)
+        .with("n + 229.128.in-addr.arpa", "whois.arin.net", 43)
+        .and_return(response = "Whois Response")
+
+      record = server.lookup("229.128.in-addr.arpa")
+      expect(record.to_s).to eq(response)
+      expect(record.parts).to eq([Whois::Record::Part.new(body: response, host: "whois.arin.net")])
+    end
+
+    it "discards newlines" do
+      server = described_class.new(*definition)
+
+      expect do
+        server.lookup("229.128.in-addr.arpa\nextra")
+      end.to raise_error(Whois::ServerError, "Invalid .in-addr.arpa address")
+    end
+  end
+end

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

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Whois::Server::Adapters::Base do
+  let(:definition) { [:tld, ".test", "whois.test", { foo: "bar" }] }
+
+
+  describe "#initialize" do
+    it "requires type, allocation, and host parameters" do
+      expect { described_class.new(:tld) }.to raise_error(ArgumentError)
+      expect { described_class.new(:tld, ".test") }.to raise_error(ArgumentError)
+      expect { described_class.new(:tld, ".test", "whois.test") }.not_to raise_error
+    end
+
+    it "accepts an options parameter" do
+      expect { described_class.new(:tld, ".test", "whois.test", { foo: "bar" }) }.not_to raise_error
+    end
+
+    it "sets instance variables from arguments" do
+      instance = described_class.new(:tld, ".test", "whois.test", { foo: "bar" })
+      expect(instance.type).to eq(:tld)
+      expect(instance.allocation).to eq(".test")
+      expect(instance.host).to eq("whois.test")
+      expect(instance.options).to eq({ foo: "bar" })
+    end
+
+    it "defaults options to an empty hash" do
+      instance = described_class.new(:tld, ".test", "whois.test")
+      expect(instance.options).to eq({})
+    end
+  end
+
+  describe "#==" do
+    it "returns true when other is the same instance" do
+      one = two = described_class.new(*definition)
+
+      expect(one == two).to be_truthy
+      expect(one).to eql(two)
+    end
+
+    it "returns true when other has same class and has the same attributes" do
+      one = described_class.new(*definition)
+      two = described_class.new(*definition)
+
+      expect(one == two).to be_truthy
+      expect(one).to eql(two)
+    end
+
+    it "returns true when other has descendant class and has the same attributes" do
+      subklass = Class.new(described_class)
+      one = described_class.new(*definition)
+      two = subklass.new(*definition)
+
+      expect(one == two).to be_truthy
+      expect(one).to eql(two)
+    end
+
+    it "returns false when other has different class and has the same attributes" do
+      one = described_class.new(*definition)
+      two = Struct.new(:type, :allocation, :host, :options).new(*definition)
+
+      expect(one == two).to be_falsey
+      expect(one).not_to eql(two)
+    end
+
+    it "returns false when other has different attributes" do
+      one = described_class.new(:tld, ".test", "whois.test")
+      two = described_class.new(:tld, ".cool", "whois.test")
+
+      expect(one == two).to be_falsey
+      expect(one).not_to eql(two)
+    end
+
+    it "returns false when other has different options" do
+      one = described_class.new(:tld, ".test", "whois.test")
+      two = described_class.new(:tld, ".test", "whois.test", { foo: "bar" })
+
+      expect(one == two).to be_falsey
+      expect(one).not_to eql(two)
+    end
+  end
+
+
+  describe "#configure" do
+    it "merges settings with current options" do
+      a = described_class.new(:tld, ".test", "whois.test", { hello: "world" })
+      a.configure(foo: "bar")
+      expect(a.options).to eq({ hello: "world", foo: "bar" })
+    end
+
+    it "gives higher priority to settings argument" do
+      a = described_class.new(:tld, ".test", "whois.test", { foo: "bar" })
+      expect(a.options).to eq({ foo: "bar" })
+      a.configure(foo: "baz")
+      expect(a.options).to eq({ foo: "baz" })
+    end
+
+    it "overrides @host if :host option exists" do
+      a = described_class.new(:tld, ".test", "whois.test", { hello: "world" })
+      a.configure(foo: "bar", host: "whois.example.com")
+      expect(a.options).to eq({ hello: "world", foo: "bar", host: "whois.example.com" })
+      expect(a.host).to eq("whois.example.com")
+    end
+  end
+
+
+  describe "#lookup" do
+    it "raises NotImplementedError" do
+      expect {
+        described_class.new(*definition).lookup("example.test")
+      }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe "#request" do
+    it "is an abstract method" do
+      expect {
+        described_class.new(*definition).request("example.test")
+      }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe "#query_the_socket" do
+    context "without :bind_host or :bind_port options" do
+      let(:server) { described_class.new(:tld, ".test", "whois.test", {}) }
+
+      it "does not bind the WHOIS query" do
+        expect(described_class.query_handler).to receive(:call).with("example.test", "whois.test", 43)
+
+        server.send(:query_the_socket, "example.test", "whois.test", 43)
+      end
+    end
+
+    context "with :bind_host and :bind_port options" do
+      let(:server) { described_class.new(:tld, ".test", "whois.test", { bind_host: "192.168.1.1", bind_port: 3000 }) }
+
+      it "binds the WHOIS query to given host and port" do
+        expect(described_class.query_handler).to receive(:call).with("example.test", "whois.test", 43, "192.168.1.1", 3000)
+
+        server.send(:query_the_socket, "example.test", "whois.test", 43)
+      end
+    end
+
+    context "with :bind_port and without :bind_host options" do
+      let(:server) { described_class.new(:tld, ".test", "whois.test", { bind_port: 3000 }) }
+
+      it "binds the WHOIS query to given port and defaults host" do
+        expect(described_class.query_handler).to receive(:call).with("example.test", "whois.test", 43, described_class::DEFAULT_BIND_HOST, 3000)
+
+        server.send(:query_the_socket, "example.test", "whois.test", 43)
+      end
+    end
+  end
+end