whois 2.6.3 → 2.6.4

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

@@ -1,41 +0,0 @@
-require "spec_helper"
-
-describe Whois::Server::Adapters::Afilias do
-
-  before(:each) do
-    @definition = [:tld, ".test", "whois.afilias-grs.info", {}]
-    @server = klass.new(*@definition)
-  end
-
-
-  describe "#query" do
-    context "without referral" do
-      it "returns the WHOIS record" do
-        response = "No match for DOMAIN.TEST."
-        expected = response
-        @server.expects(:ask_the_socket).with("domain.test", "whois.afilias-grs.info", 43).returns(response)
-
-        record = @server.query("domain.test")
-        record.to_s.should  == expected
-        record.parts.should have(1).part
-        record.parts.should == [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 DOMAIN.TEST."
-        expected = referral + "\n" + response
-        @server.expects(:ask_the_socket).with("domain.test", "whois.afilias-grs.info", 43).returns(referral)
-        @server.expects(:ask_the_socket).with("domain.test", "whois.belizenic.bz", 43).returns(response)
-
-        record = @server.query("domain.test")
-        record.to_s.should  == expected
-        record.parts.should have(2).parts
-        record.parts.should == [Whois::Record::Part.new(:body => referral, :host => "whois.afilias-grs.info"), Whois::Record::Part.new(:body => response, :host => "whois.belizenic.bz")]
-      end
-    end
-  end
-
-end

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

@@ -1,160 +0,0 @@
-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
-      lambda { klass.new(:tld) }.should raise_error(ArgumentError)
-      lambda { klass.new(:tld, ".test") }.should raise_error(ArgumentError)
-      lambda { klass.new(:tld, ".test", "whois.test") }.should_not raise_error
-    end
-
-    it "accepts an options parameter" do
-      lambda { klass.new(:tld, ".test", "whois.test", { :foo => "bar" }) }.should_not raise_error
-    end
-
-    it "sets instance variables from arguments" do
-      a = klass.new(:tld, ".test", "whois.test", { :foo => "bar" })
-      a.type.should == :tld
-      a.allocation.should == ".test"
-      a.host.should == "whois.test"
-      a.options.should == { :foo => "bar" }
-    end
-
-    it "defaults options to an empty hash" do
-      a = klass.new(:tld, ".test", "whois.test")
-      a.options.should == Hash.new
-    end
-  end
-
-  describe "#==" do
-    it "returns true when other is the same instance" do
-      one = two = klass.new(*definition)
-
-      (one == two).should be_true
-      (one.eql? two).should be_true
-    end
-
-    it "returns true when other has same class and has the same attributes" do
-      one, two = klass.new(*definition), klass.new(*definition)
-
-      (one == two).should be_true
-      (one.eql? two).should be_true
-    end
-
-    it "returns true when other has descendant class and has the same attributes" do
-      subklass = Class.new(klass)
-      one, two = klass.new(*definition), subklass.new(*definition)
-
-      (one == two).should be_true
-      (one.eql? two).should be_true
-    end
-
-    it "returns false when other has different class and has the same attributes" do
-      one, two = klass.new(*definition), Struct.new(:type, :allocation, :host, :options).new(*definition)
-
-      (one == two).should be_false
-      (one.eql? two).should be_false
-    end
-
-    it "returns false when other has different attributes" do
-      one, two = klass.new(:tld, ".test", "whois.test"), klass.new(:tld, ".cool", "whois.test")
-
-      (one == two).should be_false
-      (one.eql? two).should be_false
-    end
-
-    it "returns false when other has different options" do
-      one, two = klass.new(:tld, ".test", "whois.test"), klass.new(:tld, ".test", "whois.test", { :foo => "bar" })
-
-      (one == two).should be_false
-      (one.eql? two).should be_false
-    end
-  end
-
-
-  describe "#configure" do
-    it "merges settings with current options" do
-      a = klass.new(:tld, ".test", "whois.test", { :hello => "world" })
-      a.configure(:foo => "bar")
-      a.options.should == { :hello => "world", :foo => "bar" }
-    end
-
-    it "gives higher priority to settings argument" do
-      a = klass.new(:tld, ".test", "whois.test", { :foo => "bar" })
-      a.options.should == { :foo => "bar" }
-      a.configure(:foo => "baz")
-      a.options.should == { :foo => "baz" }
-    end
-  end
-
-
-  describe "#query" do
-    it "raises NotImplementedError" do
-      lambda { klass.new(*definition).query("example.test") }.should raise_error(NotImplementedError)
-    end
-  end
-
-  describe "#request" do
-    it "is an abstract method" do
-      lambda { klass.new(*definition).request("example.test") }.should raise_error(NotImplementedError)
-    end
-  end
-
-  describe "#query_the_socket" do
-    [ Errno::ECONNRESET, Errno::EHOSTUNREACH, Errno::ECONNREFUSED, SocketError ].each do |error|
-      it "re-raises #{error} as Whois::ConnectionError" do
-        klass.any_instance.expects(:ask_the_socket).raises(error)
-        expect {
-          klass.new(*definition).send(:query_the_socket, "example.com", "whois.test")
-        }.to raise_error(Whois::ConnectionError, "#{error}: #{error.new.message}")
-      end
-    end
-
-    context "without :bind_host or :bind_port options" do
-      before(:each) do
-        @base = klass.new(:tld, ".test", "whois.test", {})
-      end
-
-      it "does not bind the WHOIS query" do
-        @base \
-            .expects(:ask_the_socket) \
-            .with("example.test", "whois.test", 43)
-
-        @base.send(:query_the_socket, "example.test", "whois.test", 43)
-      end
-    end
-
-    context "with :bind_host and :bind_port options" do
-      before(:each) do
-        @base = klass.new(:tld, ".test", "whois.test", { :bind_host => "192.168.1.1", :bind_port => 3000 })
-      end
-
-      it "binds the WHOIS query to given host and port" do
-        @base \
-            .expects(:ask_the_socket) \
-            .with("example.test", "whois.test", 43, "192.168.1.1", 3000)
-
-        @base.send(:query_the_socket, "example.test", "whois.test", 43)
-      end
-    end
-
-    context "with :bind_port and without :bind_host options" do
-      before(:each) do
-        @base = klass.new(:tld, ".test", "whois.test", { :bind_port => 3000 })
-      end
-
-      it "binds the WHOIS query to given port and defaults host" do
-        @base \
-            .expects(:ask_the_socket) \
-            .with("example.test", "whois.test", 43, klass::DEFAULT_BIND_HOST, 3000)
-
-        @base.send(:query_the_socket, "example.test", "whois.test", 43)
-      end
-    end
-  end
-
-end

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

@@ -1,54 +0,0 @@
-require "spec_helper"
-
-describe Whois::Server::Adapters::Formatted do
-
-  before(:each) do
-    @definition = [:tld, ".de", "whois.denic.de", { :format => "-T dn,ace -C US-ASCII %s" }]
-  end
-
-
-  describe "#query" do
-    it "returns the WHOIS record" do
-      response = "Whois Response"
-      expected = response
-      server = klass.new(*@definition)
-      server.expects(:ask_the_socket).with("-T dn,ace -C US-ASCII domain.de", "whois.denic.de", 43).returns(response)
-
-      record = server.query("domain.de")
-      record.to_s.should  == expected
-      record.parts.should == [Whois::Record::Part.new(:body => response, :host => "whois.denic.de")]
-    end
-
-    context "without format option" do
-      it "raises an error" do
-        lambda do
-          server = klass.new(*[:tld, ".de", "whois.denic.de", {}])
-          server.expects(:ask_the_socket).never
-          server.query("domain.de")
-        end.should raise_error(Whois::ServerError)
-      end
-    end
-
-    context "with port option" do
-      it "sends the request to given port" do
-        response = "Whois Response"
-        server = klass.new(:tld, ".de", "whois.denic.de", { :format => "-T dn,ace -C US-ASCII %s", :port => 20 })
-        server.expects(:ask_the_socket).with("-T dn,ace -C US-ASCII domain.de", "whois.denic.de", 20).returns(response)
-
-        server.query("domain.de")
-      end
-    end
-
-    context "with bind option" do
-      it "binds the request to given host and port" do
-        response = "Whois Response"
-        server = klass.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)
-        server.expects(:ask_the_socket).with("-T dn,ace -C US-ASCII domain.de", "whois.denic.de", 43, "192.168.1.1", 3000).returns(response)
-
-        server.query("domain.de")
-      end
-    end
-  end
-
-end

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

@@ -1,22 +0,0 @@
-require "spec_helper"
-
-describe Whois::Server::Adapters::None do
-
-  describe "#query" do
-    it "raises Whois::NoInterfaceError" do
-      lambda do
-        klass.new(:tld, ".test", nil).query("example.test")
-      end.should raise_error(Whois::NoInterfaceError)
-    end
-
-    it "customizes the error message according to the type" do
-      lambda do
-        klass.new(:tld, ".test", nil).query("example.test")
-      end.should raise_error(Whois::NoInterfaceError, /tld/)
-      lambda do
-        klass.new(:ipv4, "127.0.0.1", nil).query("127.0.0.1")
-      end.should raise_error(Whois::NoInterfaceError, /ipv4/)
-    end
-  end
-
-end

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

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

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

@@ -1,41 +0,0 @@
-require "spec_helper"
-
-describe Whois::Server::Adapters::Pir do
-
-  before(:each) do
-    @definition = [:tld, ".test", "whois.publicinterestregistry.net", {}]
-    @server = klass.new(*@definition)
-  end
-
-
-  describe "#query" do
-    context "without referral" do
-      it "returns the WHOIS record" do
-        response = "No match for DOMAIN.TEST."
-        expected = response
-        @server.expects(:ask_the_socket).with("FULL domain.test", "whois.publicinterestregistry.net", 43).returns(response)
-
-        record = @server.query("domain.test")
-        record.to_s.should  == expected
-        record.parts.should have(1).part
-        record.parts.should == [Whois::Record::Part.new(:body => response, :host => "whois.publicinterestregistry.net")]
-      end
-    end
-
-    context "with referral" do
-      it "follows all referrals" do
-        referral = File.read(fixture("referrals/pir.org.txt"))
-        response = "Match for DOMAIN.TEST."
-        expected = referral + "\n" + response
-        @server.expects(:ask_the_socket).with("FULL domain.test", "whois.publicinterestregistry.net", 43).returns(referral)
-        @server.expects(:ask_the_socket).with("domain.test", "whois.iana.org", 43).returns(response)
-
-        record = @server.query("domain.test")
-        record.to_s.should  == expected
-        record.parts.should have(2).parts
-        record.parts.should == [Whois::Record::Part.new(:body => referral, :host => "whois.publicinterestregistry.net"), Whois::Record::Part.new(:body => response, :host => "whois.iana.org")]
-      end
-    end
-  end
-
-end

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

@@ -1,44 +0,0 @@
-require "spec_helper"
-
-describe Whois::Server::Adapters::Standard do
-
-  before(:each) do
-    @definition = [:tld, ".test", "whois.test", {}]
-  end
-
-
-  describe "#query" do
-    it "returns the WHOIS record" do
-      response = "Whois Response"
-      expected = response
-      server = klass.new(*@definition)
-      server.expects(:ask_the_socket).with("domain.test", "whois.test", 43).returns(response)
-
-      record = server.query("domain.test")
-      record.to_s.should  == expected
-      record.parts.should == [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 = klass.new(:tld, ".test", "whois.test", { :port => 20 })
-        server.expects(:ask_the_socket).with("domain.test", "whois.test", 20).returns(response)
-
-        server.query("domain.test")
-      end
-    end
-
-    context "with bind option" do
-      it "binds the request to given host and port" do
-        response = "Whois Response"
-        server = klass.new(:tld, ".test", "whois.test", { :port => 20 })
-        server.configure(:bind_host => "192.168.1.100", :bind_port => 3000)
-        server.expects(:ask_the_socket).with("domain.test", "whois.test", 20, "192.168.1.100", 3000).returns(response)
-
-        server.query("domain.test")
-      end
-    end
-  end
-
-end

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

@@ -1,70 +0,0 @@
-require "spec_helper"
-
-describe Whois::Server::Adapters::Verisign do
-
-  before(:each) do
-    @definition = [:tld, ".test", "whois.test", {}]
-    @server = klass.new(*@definition)
-  end
-
-
-  describe "#query" do
-    context "without referral" do
-      it "returns the WHOIS record" do
-        response = "No match for DOMAIN.TEST."
-        expected = response
-        @server.expects(:ask_the_socket).with("=domain.test", "whois.test", 43).returns(response)
-
-        record = @server.query("domain.test")
-        record.to_s.should  == expected
-        record.parts.should have(1).part
-        record.parts.should == [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 DOMAIN.TEST."
-        expected = referral + "\n" + response
-        @server.expects(:ask_the_socket).with("=domain.test", "whois.test", 43).returns(referral)
-        @server.expects(:ask_the_socket).with("domain.test", "whois.markmonitor.com", 43).returns(response)
-
-        record = @server.query("domain.test")
-        record.to_s.should  == expected
-        record.parts.should have(2).parts
-        record.parts.should == [Whois::Record::Part.new(:body => referral, :host => "whois.test"), Whois::Record::Part.new(:body => response, :host => "whois.markmonitor.com")]
-      end
-
-      it "extracts the closest referral when multiple referrals" do
-        referral = File.read(fixture("referrals/crsnic.com_referral_multiple.txt"))
-        @server.expects(:ask_the_socket).with("=domain.test", "whois.test", 43).returns(referral)
-        @server.expects(:ask_the_socket).with("domain.test", "whois.markmonitor.com", 43).returns("")
-
-        record = @server.query("domain.test")
-        record.parts.should have(2).parts
-      end
-
-      it "ignores referral when is not defined" do
-        referral = File.read(fixture("referrals/crsnic.com_referral_not_defined.txt"))
-        @server.expects(:ask_the_socket).with("=domain.test", "whois.test", 43).returns(referral)
-        @server.expects(:ask_the_socket).never
-
-        record = @server.query("domain.test")
-        record.parts.should have(1).part
-      end
-
-      # (see #103)
-      # This is the case of vrsn-20100925-dnssecmonitor86.net
-      it "gracefully ignores referral when is missing" do
-        referral = File.read(fixture("referrals/crsnic.com_referral_missing.txt"))
-        @server.expects(:ask_the_socket).with("=domain.test", "whois.test", 43).returns(referral)
-        @server.expects(:ask_the_socket).never
-
-        record = @server.query("domain.test")
-        record.parts.should have(1).part
-      end
-    end
-  end
-
-end