whois 2.6.3 → 2.6.4

data/spec/whois/client_spec.rb

@@ -1,134 +0,0 @@
-require "spec_helper"
-
-describe Whois::Client do
-
-  describe "#initialize" do
-    it "accepts a zero parameters" do
-      lambda { klass.new }.should_not raise_error
-    end
-
-    it "accepts a settings parameter" do
-      lambda { klass.new({ :foo => "bar" }) }.should_not raise_error
-    end
-
-
-    it "accepts a timeout setting with a value in seconds" do
-      client = klass.new(:timeout => 100)
-      client.timeout.should == 100
-    end
-
-    it "accepts a timeout setting with a nil value" do
-      client = klass.new(:timeout => nil)
-      client.timeout.should be_nil
-    end
-
-    it "accepts a block" do
-      klass.new do |client|
-        client.should be_instance_of(klass)
-      end
-    end
-
-
-    it "defaults timeout setting to DEFAULT_TIMEOUT" do
-      client = klass.new
-      client.timeout.should == klass::DEFAULT_TIMEOUT
-    end
-
-    it "sets settings to given argument, except timeout" do
-      client = klass.new(:timeout => nil, :foo => "bar")
-      client.settings.should == { :foo => "bar" }
-    end
-  end
-
-  describe "#query" do
-    it "converts the argument to string" do
-      # I can't use the String in place of instance_of(String)
-      # because Array#to_s behaves differently
-      # on Ruby 1.8.7 and Ruby 1.9.1
-      # http://redmine.ruby-lang.org/issues/show/2617
-
-      server = Whois::Server::Adapters::Base.new(:tld, ".test", "whois.test")
-      server.expects(:query).with(instance_of(String))
-      Whois::Server.expects(:guess).with(instance_of(String)).returns(server)
-      klass.new.query(["example", ".", "test"])
-    end
-
-    it "converts the argument to downcase" do
-      server = Whois::Server::Adapters::Base.new(:tld, ".test", "whois.test")
-      server.expects(:query).with("example.test")
-      Whois::Server.expects(:guess).with("example.test").returns(server)
-      klass.new.query("Example.TEST")
-    end
-
-    it "detects email" do
-      lambda do
-        klass.new.query("weppos@weppos.net")
-      end.should raise_error(Whois::ServerNotSupported)
-    end
-
-    it "works with domain with no whois" do
-      Whois::Server.define(:tld, ".nowhois", nil, :adapter => Whois::Server::Adapters::None)
-
-      lambda do
-        klass.new.query("domain.nowhois")
-      end.should 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, :web => "www.nic.test")
-
-      lambda do
-        klass.new.query("domain.webwhois")
-      end.should raise_error(Whois::WebInterfaceError, /www\.nic\.test/)
-    end
-
-    it "raises if timeout is exceeded" do
-      adapter = Class.new(Whois::Server::Adapters::Base) do
-        def query(*args)
-          sleep(2)
-        end
-      end
-      Whois::Server.expects(:guess).returns(adapter.new(:tld, ".test", "whois.test"))
-
-      client = klass.new(:timeout => 1)
-      lambda { client.query("example.test") }.should raise_error(Timeout::Error)
-    end
-
-    it "does not raise if timeout is not exceeded" do
-      adapter = Class.new(Whois::Server::Adapters::Base) do
-        def query(*args)
-          sleep(1)
-        end
-      end
-      Whois::Server.expects(:guess).returns(adapter.new(:tld, ".test", "whois.test"))
-
-      client = klass.new(:timeout => 5)
-      lambda { client.query("example.test") }.should_not raise_error
-    end
-
-    it "supports unlimited timeout" do
-      adapter = Class.new(Whois::Server::Adapters::Base) do
-        def query(*args)
-          sleep(1)
-        end
-      end
-      Whois::Server.expects(:guess).returns(adapter.new(:tld, ".test", "whois.test"))
-
-      client = klass.new.tap { |c| c.timeout = nil }
-      lambda { client.query("example.test") }.should_not raise_error
-    end
-
-  end
-
-  # FIXME: use RSpec metadata
-  need_connectivity do
-    describe "#query" do
-      it "sends a query for given domain" do
-        record = klass.new.query("weppos.it")
-        assert record.match?(/Domain:\s+weppos\.it/)
-        assert record.match?(/Created:/)
-      end
-    end
-  end
-
-end

data/spec/whois/core_ext_spec.rb

@@ -1,17 +0,0 @@
-require "spec_helper"
-
-describe DateTime do
-
-  describe "#to_time" do
-    it "should work" do
-      DateTime.new(2005, 2, 21, 10, 11, 12, 0, 0).to_time.should == Time.utc(2005, 2, 21, 10, 11, 12)
-
-      # NOTE: This test doesn't pass with Ruby 1.9, not because it doesn't work,
-      # but because Ruby 1.9 has a different implementation.
-      # ActiveRecord solves this by always removing the original Ruby method.
-      # DateTimes with offsets other than 0 are returned unaltered
-      # assert_equal DateTime.new(2005, 2, 21, 10, 11, 12, Rational(-5, 24)), DateTime.new(2005, 2, 21, 10, 11, 12, Rational(-5, 24)).to_time
-    end
-  end
-
-end

data/spec/whois/errors_spec.rb

@@ -1,21 +0,0 @@
-require "spec_helper"
-
-describe Whois::WebInterfaceError do
-
-  describe "#initialize" do
-    it "sets the URL" do
-      klass.new("http://example.com").url.should == "http://example.com"
-    end
-
-    it "requires the URL argument" do
-      lambda { klass.new }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "#message" do
-    it "interpolates the URL" do
-      klass.new("http://example.com").message.should match(%r{http://example.com})
-    end
-  end
-
-end

data/spec/whois/record/contact_spec.rb

@@ -1,57 +0,0 @@
-require "spec_helper"
-
-describe Whois::Record::Contact do
-
-  it "inherits from SuperStruct" do
-    klass.ancestors.should include(SuperStruct)
-  end
-
-
-  describe "#initialize" do
-    it "accepts an empty value" do
-      lambda do
-        i = klass.new
-        i.id.should be_nil
-      end.should_not raise_error
-    end
-
-    it "accepts an empty hash" do
-      lambda do
-        i = klass.new({})
-        i.id.should be_nil
-      end.should_not raise_error
-    end
-
-    # it "initializes a new instance from given params" do
-    #   i = klass.new(10, klass::TYPE_REGISTRANT, "John Doe", nil)
-
-    #   i.id.should == 10
-    #   i.type.should == klass::TYPE_REGISTRANT
-    #   i.name.should == "John Doe"
-    #   i.organization.should be_nil
-    # end
-
-    it "initializes a new instance from given hash" do
-      i = klass.new(:id => 10, :name => "John Doe", :type => klass::TYPE_REGISTRANT)
-
-      i.id.should == 10
-      i.type.should == klass::TYPE_REGISTRANT
-      i.name.should == "John Doe"
-      i.organization.should be_nil
-    end
-
-    it "initializes a new instance from given block" do
-      i = klass.new do |c|
-        c.id    = 10
-        c.type  = klass::TYPE_REGISTRANT
-        c.name  = "John Doe"
-      end
-
-      i.id.should == 10
-      i.type.should == klass::TYPE_REGISTRANT
-      i.name.should == "John Doe"
-      i.organization.should be_nil
-    end
-  end
-
-end

data/spec/whois/record/nameserver_spec.rb

@@ -1,61 +0,0 @@
-require "spec_helper"
-
-describe Whois::Record::Nameserver do
-
-  it "inherits from SuperStruct" do
-    klass.ancestors.should include(SuperStruct)
-  end
-
-
-  describe "#initialize" do
-    it "accepts an empty value" do
-      lambda do
-        i = klass.new
-        i.name.should be_nil
-      end.should_not raise_error
-    end
-
-    it "accepts an empty hash" do
-      lambda do
-        i = klass.new({})
-        i.name.should be_nil
-      end.should_not raise_error
-    end
-
-    # it "initializes a new instance from given params" do
-    #   i = klass.new("ns1.example.com", "127.0.0.1")
-
-    #   i.name.should == "ns1.example.com"
-    #   i.ipv4.should == "127.0.0.1"
-    #   i.ipv6.should be_nil
-    # end
-
-    it "initializes a new instance from given hash" do
-      i = klass.new(:name => "ns1.example.com", :ipv4 => "127.0.0.1")
-
-      i.name.should == "ns1.example.com"
-      i.ipv4.should == "127.0.0.1"
-      i.ipv6.should be_nil
-    end
-
-    it "initializes a new instance from given block" do
-      i = klass.new do |c|
-        c.name  = "ns1.example.com"
-        c.ipv4  = "127.0.0.1"
-      end
-
-      i.name.should == "ns1.example.com"
-      i.ipv4.should == "127.0.0.1"
-      i.ipv6.should be_nil
-    end
-  end
-
-  describe "#to_s" do
-    it "returns the string representation of this object" do
-      klass.new(:name => "ns1.example.com").to_s.should == "ns1.example.com"
-      klass.new(:name => nil).to_s.should == ""
-      klass.new.to_s.should == ""
-    end
-  end
-
-end

data/spec/whois/record/parser/base_spec.rb

@@ -1,242 +0,0 @@
-require 'spec_helper'
-
-describe Whois::Record::Parser::Base do
-
-  before(:each) do
-    @part = Whois::Record::Part.new(:body => "This is the response.", :host => "whois.example.test")
-  end
-
-
-  describe ".property_register" do
-    it "register given property" do
-      koncrete = Class.new(klass)
-      koncrete.property_register(:greetings, :supported)
-
-      koncrete._properties[:greetings].should == :supported
-    end
-  end
-
-  describe "#property_supported?" do
-    it "returns false if the property is not supported" do
-      koncrete = Class.new(klass) do
-      end
-      koncrete.new(@part).property_supported?(:disclaimer).should be_false
-      koncrete.new(@part).respond_to?(:disclaimer).should be_true
-    end
-
-    it "returns true if the property is supported" do
-      koncrete = Class.new(klass) do
-        property_register(:disclaimer, :supported) {}
-      end
-      koncrete.new(@part).property_supported?(:disclaimer).should be_true
-      koncrete.new(@part).respond_to?(:disclaimer).should be_true
-    end
-  end
-
-
-  describe "#initialize" do
-    it "requires a part" do
-      lambda { klass.new }.should raise_error(ArgumentError)
-      lambda { klass.new(@part) }.should_not raise_error
-    end
-
-    it "sets the part" do
-      klass.new(@part).part.should be(@part)
-    end
-  end
-
-  describe "#content" do
-    it "returns the part body" do
-      i = klass.new(@part)
-      i.content.should be(@part.body)
-    end
-  end
-
-  describe "#content_for_scanner" do
-    it "returns the part body with line feed normalized" do
-      i = klass.new(Whois::Record::Part.new(:body => "This is\r\nthe response.", :host => "whois.example.test"))
-      i.send(:content_for_scanner).should == "This is\nthe response."
-    end
-
-    it "caches the result" do
-      i = klass.new(Whois::Record::Part.new(:body => "This is\r\nthe response.", :host => "whois.example.test"))
-      i.instance_eval { @content_for_scanner }.should be_nil
-      i.send(:content_for_scanner)
-      i.instance_eval { @content_for_scanner }.should == "This is\nthe response."
-    end
-  end
-
-  describe "#is" do
-    it "calls the method if the object respond to the method" do
-      koncrete = Class.new(klass) { def response_throttled?; true; end }.new(Whois::Record::Part.new)
-      koncrete.is(:response_throttled?)
-    end
-    it "does not call the method if the object does not respond to the method" do
-      koncrete = Class.new(klass).new(Whois::Record::Part.new)
-      koncrete.is(:response_throttled?).should be_false
-    end
-  end
-
-  describe "#validate!" do
-    it "raises Whois::ResponseIsThrottled when the response is throttled" do
-      koncrete = Class.new(klass) { def response_throttled?; true; end }.new(Whois::Record::Part.new)
-      lambda { koncrete.validate! }.should raise_error(Whois::ResponseIsThrottled)
-
-      koncrete = Class.new(klass) { def response_throttled?; false; end }.new(Whois::Record::Part.new)
-      lambda { koncrete.validate! }.should_not raise_error
-    end
-
-    it "raises Whois::ResponseIsUnavailable when the response is unavailable" do
-      koncrete = Class.new(klass) { def response_unavailable?; true; end }.new(Whois::Record::Part.new)
-      lambda { koncrete.validate! }.should raise_error(Whois::ResponseIsUnavailable)
-
-      koncrete = Class.new(klass) { def response_unavailable?; false; end }.new(Whois::Record::Part.new)
-      lambda { koncrete.validate! }.should_not raise_error
-    end
-  end
-
-
-  describe "#changed?" do
-    it "raises if the argument is not an instance of the same class" do
-      lambda do
-        klass.new(@part).changed?(Object.new)
-      end.should raise_error
-
-      lambda do
-        klass.new(@part).changed?(klass.new(@part))
-      end.should_not raise_error
-    end
-  end
-
-  describe "#unchanged?" do
-    it "raises if the argument is not an instance of the same class" do
-      lambda do
-        klass.new(@part).unchanged?(Object.new)
-      end.should raise_error
-
-      lambda do
-        klass.new(@part).unchanged?(klass.new(@part))
-      end.should_not raise_error
-    end
-
-    it "returns true if self and other references the same object" do
-      i = klass.new(@part)
-      i.unchanged?(i).should be_true
-    end
-
-    it "returns true if the content_for_scanner is the same" do
-      i = klass.new(Whois::Record::Part.new(:body => "This is the\nresponse 1.", :host => "whois.example.test"))
-      o = klass.new(Whois::Record::Part.new(:body => "This is the\r\nresponse 1.", :host => "whois.example.test"))
-      i.unchanged?(o).should be_true
-    end
-
-    it "returns false if the content_for_scanner is not the same" do
-      i = klass.new(Whois::Record::Part.new(:body => "This is the response 1.", :host => "whois.example.test"))
-      o = klass.new(Whois::Record::Part.new(:body => "This is the response 2.", :host => "whois.example.test"))
-      i.unchanged?(o).should be_false
-    end
-  end
-
-  describe "#contacts" do
-    it "returns an array of contacts" do
-      c1 = Whois::Record::Contact.new(:id => "1st", :name => "foo")
-      c2 = Whois::Record::Contact.new(:id => "2nd", :name => "foo")
-      c3 = Whois::Record::Contact.new(:id => "3rd", :name => "foo")
-      koncrete = Class.new(klass) do
-        property_supported(:registrant_contacts) { [c1, c2] }
-        property_supported(:admin_contacts)      { [] }
-        property_supported(:technical_contacts)  { [c3] }
-      end.new(@part)
-
-      koncrete.contacts.should == [c1, c2, c3]
-    end
-
-    it "returns an empty array when no contact is supported" do
-      i = klass.new(@part)
-      i.contacts.should == []
-    end
-  end
-
-
-  describe "#response_incomplete?" do
-    it "is undefined" do
-      klass.new(@part).respond_to?(:response_incomplete?).should be_false
-    end
-
-    # it "returns nil" do
-    #   i = klass.new(@part)
-    #   i.response_incomplete?.should be_nil
-    # end
-    #
-    # it "is false" do
-    #   i = klass.new(@part)
-    #   i.response_incomplete?.should be_false
-    # end
-  end
-
-  describe "#response_throttled?" do
-    it "is undefined" do
-      klass.new(@part).respond_to?(:response_throttled?).should be_false
-    end
-
-    # it "returns nil" do
-    #   i = klass.new(@part)
-    #   i.response_throttled?.should be_nil
-    # end
-    #
-    # it "is false" do
-    #   i = klass.new(@part)
-    #   i.response_throttled?.should be_false
-    # end
-  end
-
-  describe "#response_unavailable?" do
-    it "is undefined" do
-      klass.new(@part).respond_to?(:response_unavailable?).should be_false
-    end
-
-    # it "returns nil" do
-    #   i = klass.new(@part)
-    #   i.response_unavailable?.should be_nil
-    # end
-    #
-    # it "is false" do
-    #   i = klass.new(@part)
-    #   i.response_unavailable?.should be_false
-    # end
-  end
-
-end
-
-describe Whois::Record::Parser::Base, "Parser Behavior" do
-
-  Klass = Class.new(Whois::Record::Parser::Base) do
-    property_supported(:domain) { "example.com" }
-    property_not_supported(:domain_id)
-
-    def response_throttled?
-      part.host == "throttled.whois.test"
-    end
-  end
-
-  context "property supported" do
-    it "raises Whois::ResponseIsThrottled when the response is throttled" do
-      i = Klass.new(Whois::Record::Part.new(:body => "", :host => "throttled.whois.test"))
-      lambda { i.domain }.should raise_error(Whois::ResponseIsThrottled)
-
-      i = Klass.new(Whois::Record::Part.new(:body => "", :host => "success.whois.test"))
-      lambda { i.domain }.should_not raise_error
-    end
-  end
-
-  context "property not supported" do
-    it "raises Whois::ResponseIsThrottled when the response is throttled" do
-      i = Klass.new(Whois::Record::Part.new(:body => "", :host => "throttled.whois.test"))
-      lambda { i.domain_id }.should raise_error(Whois::PropertyNotSupported)
-
-      i = Klass.new(Whois::Record::Part.new(:body => "", :host => "success.whois.test"))
-      lambda { i.domain_id }.should raise_error(Whois::PropertyNotSupported)
-    end
-  end
-
-end