whois 5.0.1 → 5.1.1

data/spec/whois/client_spec.rb

@@ -1,14 +1,15 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::Client do
-
   describe "#initialize" do
     it "accepts a zero parameters" do
-      expect { described_class.new }.to_not raise_error
+      expect { described_class.new }.not_to raise_error
     end
 
     it "accepts a settings parameter" do
-      expect { described_class.new({ foo: "bar" }) }.to_not raise_error
+      expect { described_class.new({ foo: "bar" }) }.not_to raise_error
     end
 
 
@@ -111,7 +112,7 @@ describe Whois::Client do
       client = described_class.new(timeout: 5)
       expect {
         client.lookup("example.test")
-      }.to_not raise_error
+      }.not_to raise_error
     end
 
     it "supports unlimited timeout" do
@@ -125,9 +126,8 @@ describe Whois::Client do
       client = described_class.new.tap { |c| c.timeout = nil }
       expect {
         client.lookup("example.test")
-      }.to_not raise_error
+      }.not_to raise_error
     end
-
   end
 
   # FIXME: use RSpec metadata
@@ -135,10 +135,9 @@ describe Whois::Client do
     describe "#query" do
       it "sends a query for given domain" do
         record = described_class.new.lookup("weppos.it")
-        assert record.match?(/Domain:\s+weppos\.it/)
-        assert record.match?(/Created:/)
+        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

@@ -1,20 +1,21 @@
+# 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
-      }.to_not raise_error
+      }.not_to raise_error
     end
 
     it "accepts an empty hash" do
       expect {
         instance = described_class.new({})
         expect(instance.body).to be_nil
-      }.to_not raise_error
+      }.not_to raise_error
     end
 
     it "initializes a new instance from given hash" do
@@ -34,5 +35,4 @@ describe Whois::Record::Part do
       expect(instance.host).to eq("whois.example.test")
     end
   end
-
 end

data/spec/whois/record_spec.rb

@@ -1,16 +1,19 @@
+# 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(: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")
   }
@@ -20,7 +23,7 @@ describe Whois::Record 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
+      expect { described_class.new(server, parts) }.not_to raise_error
     end
 
     it "sets server and parts from arguments" do
@@ -135,8 +138,8 @@ describe Whois::Record do
 
   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)
+      expect(subject.match?(/record/)).to be(true)
+      expect(subject.match?(/nomatch/)).to be(false)
     end
   end
 
@@ -154,5 +157,4 @@ describe Whois::Record do
       expect(described_class.new(nil, []).content).to eq("")
     end
   end
-
 end

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

@@ -1,7 +1,8 @@
+# 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) }
 
@@ -24,7 +25,7 @@ describe Whois::Server::Adapters::Afilias do
       it "follows all referrals" do
         referral = File.read(fixture("referrals/afilias.bz.txt"))
         response = "Match for example.test."
-        expected = referral + "\n" + response
+        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)
 
@@ -38,12 +39,11 @@ describe Whois::Server::Adapters::Afilias 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
+        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

@@ -1,7 +1,8 @@
+# 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) }
 
@@ -22,7 +23,7 @@ describe Whois::Server::Adapters::Arin do
       it "follows whois:// referrals" do
         referral = File.read(fixture("referrals/arin_referral_whois.txt"))
         response = "Whois Response"
-        expected = referral + "\n" + 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)
 
@@ -30,13 +31,13 @@ describe Whois::Server::Adapters::Arin do
         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")])
+                                    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
+        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)
 
@@ -44,14 +45,14 @@ describe Whois::Server::Adapters::Arin do
         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")])
+                                    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
+        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)
@@ -60,7 +61,7 @@ describe Whois::Server::Adapters::Arin do
       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
+        expect(server.query_handler).not_to receive(:call)
 
         record = server.lookup("0.0.0.0")
         expect(record.parts.size).to eq(1)
@@ -75,10 +76,8 @@ describe Whois::Server::Adapters::Arin do
         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")])
+                                    Whois::Record::Part.new(body: response, host: "whois.apnic.net"),])
       end
     end
-
   end
-
 end

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

@@ -1,8 +1,9 @@
+# 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
@@ -16,5 +17,4 @@ describe Whois::Server::Adapters::Arpa do
       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

@@ -1,19 +1,20 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::Server::Adapters::Base do
-
-  let(:definition)  { [:tld, ".test", "whois.test", { foo: "bar" }] }
+  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
+      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" }) }.to_not raise_error
+      expect { described_class.new(:tld, ".test", "whois.test", { foo: "bar" }) }.not_to raise_error
     end
 
     it "sets instance variables from arguments" do
@@ -78,22 +79,22 @@ describe Whois::Server::Adapters::Base do
 
   describe "#configure" do
     it "merges settings with current options" do
-      a = described_class.new(:tld, ".test", "whois.test", { :hello => "world" })
+      a = described_class.new(:tld, ".test", "whois.test", { hello: "world" })
       a.configure(foo: "bar")
-      expect(a.options).to eq({ :hello => "world", 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" })
+      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 = 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.options).to eq({ hello: "world", foo: "bar", host: "whois.example.com" })
       expect(a.host).to eq("whois.example.com")
     end
   end
@@ -127,7 +128,7 @@ describe Whois::Server::Adapters::Base do
     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 }) }
+      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)
@@ -137,7 +138,7 @@ describe Whois::Server::Adapters::Base do
     end
 
     context "with :bind_port and without :bind_host options" do
-      let(:server) { described_class.new(:tld, ".test", "whois.test", { :bind_port => 3000 }) }
+      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)
@@ -146,5 +147,4 @@ describe Whois::Server::Adapters::Base do
       end
     end
   end
-
 end

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

@@ -1,8 +1,9 @@
+# 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" }] }
+  let(:definition) { [:tld, ".de", "whois.denic.de", { format: "-T dn,ace -C US-ASCII %s" }] }
 
 
   describe "#lookup" do
@@ -19,8 +20,8 @@ describe Whois::Server::Adapters::Formatted do
 
     context "without format option" do
       it "raises an error" do
-        server = described_class.new(*[:tld, ".de", "whois.denic.de", {}])
-        expect(server.query_handler).to receive(:call).never
+        server = described_class.new(:tld, ".de", "whois.denic.de", {})
+        expect(server.query_handler).not_to receive(:call)
 
         expect {
           server.lookup("domain.de")
@@ -31,7 +32,7 @@ describe Whois::Server::Adapters::Formatted do
     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 })
+        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")
@@ -41,13 +42,12 @@ describe Whois::Server::Adapters::Formatted do
     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)
+        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

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::Server::Adapters::None do
-
   describe "#lookup" do
     it "raises Whois::NoInterfaceError" do
       expect {
@@ -19,5 +20,4 @@ describe Whois::Server::Adapters::None do
       }.to raise_error(Whois::NoInterfaceError, /ipv4/)
     end
   end
-
 end

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

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::Server::Adapters::NotImplemented do
-
-  before(:each) do
-    @definition = [:ipv6, "2001:0000::/32", "teredo", { :adapter => Whois::Server::Adapters::NotImplemented }]
+  before do
+    @definition = [:ipv6, "2001:0000::/32", "teredo", { adapter: Whois::Server::Adapters::NotImplemented }]
   end
 
 
@@ -20,5 +21,4 @@ describe Whois::Server::Adapters::NotImplemented do
       }.to raise_error(Whois::ServerNotImplemented, /teredo/)
     end
   end
-
 end

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

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::Server::Adapters::Standard do
-
   let(:definition) { [:tld, ".test", "whois.test", {}] }
 
 
@@ -20,7 +21,7 @@ describe Whois::Server::Adapters::Standard do
     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 })
+        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")
@@ -30,13 +31,12 @@ describe Whois::Server::Adapters::Standard do
     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)
+        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

@@ -1,7 +1,8 @@
+# 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) }
 
@@ -24,7 +25,7 @@ describe Whois::Server::Adapters::Verisign do
       it "follows all referrals" do
         referral = File.read(fixture("referrals/crsnic.com.txt"))
         response = "Match for example.test."
-        expected = referral + "\n" + response
+        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)
 
@@ -38,7 +39,7 @@ describe Whois::Server::Adapters::Verisign 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).to receive(:call).never
+        expect(server.query_handler).not_to receive(:call)
 
         record = server.lookup("example.test")
         expect(record.parts.size).to eq(1)
@@ -49,12 +50,11 @@ describe Whois::Server::Adapters::Verisign do
       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).to receive(:call).never
+        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

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::Server::Adapters::Web do
-
-  before(:each) do
-    @definition = [:tld, ".test", nil, { :url => "http://whois.test" }]
+  before do
+    @definition = [:tld, ".test", nil, { url: "http://whois.test" }]
   end
 
 
@@ -20,5 +21,4 @@ describe Whois::Server::Adapters::Web do
       }.to raise_error(Whois::WebInterfaceError, /whois\.test/)
     end
   end
-
 end

data/spec/whois/server/socket_handler_spec.rb

@@ -1,10 +1,11 @@
+# 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|
+    [Errno::ECONNRESET, Errno::EHOSTUNREACH, Errno::ECONNREFUSED, Errno::ETIMEDOUT, Errno::EPIPE, SocketError].each do |error|
       it "re-raises #{error} as Whois::ConnectionError" do
         expect(subject).to receive(:execute).and_raise(error)
         expect {
@@ -13,15 +14,16 @@ describe Whois::Server::SocketHandler do
       end
 
       it "executes a socket connection for given args" do
-        socket = double("Handler")
+        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)
+        expect(TCPSocket).to receive(:new)
+          .with("whois.test", 43)
+          .and_return(socket)
         subject.call("example.test", "whois.test", 43)
       end
     end
   end
-
 end