whois 4.0.8 → 4.1.0

data/spec/whois/errors_spec.rb

@@ -0,0 +1,23 @@
+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 {
+        described_class.new
+      }.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/record/part_spec.rb

@@ -0,0 +1,38 @@
+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
+      }.to_not raise_error
+    end
+
+    it "accepts an empty hash" do
+      expect {
+        instance = described_class.new({})
+        expect(instance.body).to be_nil
+      }.to_not 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,158 @@
+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) }.to_not 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.eql?(two)).to be_truthy
+    end
+
+    it "returns true when other has same class and has the same parts" do
+      one, two = described_class.new(server, parts), described_class.new(server, parts)
+
+      expect(one == two).to be_truthy
+      expect(one.eql?(two)).to be_truthy
+    end
+
+    it "returns true when other has descendant class and has the same parts" do
+      subklass = Class.new(described_class)
+      one, two = described_class.new(server, parts), subklass.new(server, parts)
+
+      expect(one == two).to be_truthy
+      expect(one.eql?(two)).to be_truthy
+    end
+
+    it "returns true when other has same class and has equal parts" do
+      one, two = described_class.new(server, parts), described_class.new(server, parts.dup)
+
+      expect(one == two).to be_truthy
+      expect(one.eql?(two)).to be_truthy
+    end
+
+    it "returns true when other has same class, different server and the same parts" do
+      one, two = described_class.new(server, parts), described_class.new(nil, parts)
+
+      expect(one == two).to be_truthy
+      expect(one.eql?(two)).to be_truthy
+    end
+
+    it "returns false when other has different class and has the same parts" do
+      one, two = described_class.new(server, parts), Struct.new(:server, :parts).new(server, parts)
+
+      expect(one == two).to be_falsey
+      expect(one.eql?(two)).to be_falsey
+    end
+
+    it "returns false when other has different parts" do
+      one, two = described_class.new(server, parts), described_class.new(server, [])
+
+      expect(one == two).to be_falsey
+      expect(one.eql?(two)).to be_falsey
+    end
+
+    it "returns false when other is string and has the same content" do
+      one, two = described_class.new(server, parts), described_class.new(server, parts).to_s
+
+      expect(one == two).to be_falsey
+      expect(one.eql?(two)).to be_falsey
+    end
+
+    it "returns false when other is string and has different content" do
+      one, two = described_class.new(server, parts), "different"
+
+      expect(one == two).to be_falsey
+      expect(one.eql?(two)).to be_falsey
+    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 eq(true)
+      expect(subject.match?(/nomatch/)).to eq(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 @@
+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).to receive(:call).with("example.test", "whois.belizenic.bz", 43).never
+
+        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,84 @@
+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).to receive(:call).with("0.0.0.0", "whois.ripe.net", 43).never
+
+        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).to receive(:call).never
+
+        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,20 @@
+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
+      response = "Whois Response"
+      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)
+
+      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
+  end
+
+end

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

@@ -0,0 +1,150 @@
+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") }.to_not raise_error
+    end
+
+    it "accepts an options parameter" do
+      expect { described_class.new(:tld, ".test", "whois.test", { foo: "bar" }) }.to_not 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.eql?(two)).to be_truthy
+    end
+
+    it "returns true when other has same class and has the same attributes" do
+      one, two = described_class.new(*definition), described_class.new(*definition)
+
+      expect(one == two).to be_truthy
+      expect(one.eql?(two)).to be_truthy
+    end
+
+    it "returns true when other has descendant class and has the same attributes" do
+      subklass = Class.new(described_class)
+      one, two = described_class.new(*definition), subklass.new(*definition)
+
+      expect(one == two).to be_truthy
+      expect(one.eql?(two)).to be_truthy
+    end
+
+    it "returns false when other has different class and has the same attributes" do
+      one, two = described_class.new(*definition), Struct.new(:type, :allocation, :host, :options).new(*definition)
+
+      expect(one == two).to be_falsey
+      expect(one.eql?(two)).to be_falsey
+    end
+
+    it "returns false when other has different attributes" do
+      one, two = described_class.new(:tld, ".test", "whois.test"), described_class.new(:tld, ".cool", "whois.test")
+
+      expect(one == two).to be_falsey
+      expect(one.eql?(two)).to be_falsey
+    end
+
+    it "returns false when other has different options" do
+      one, two = described_class.new(:tld, ".test", "whois.test"), described_class.new(:tld, ".test", "whois.test", { foo: "bar" })
+
+      expect(one == two).to be_falsey
+      expect(one.eql?(two)).to be_falsey
+    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