whois 5.0.1 → 5.0.2

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
@@ -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)
 
@@ -45,5 +46,4 @@ describe Whois::Server::Adapters::Afilias do
       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,7 +45,7 @@ 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
@@ -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,7 +20,7 @@ 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", {}])
+        server = described_class.new(:tld, ".de", "whois.denic.de", {})
         expect(server.query_handler).to receive(:call).never
 
         expect {
@@ -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 }]
+    @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)
 
@@ -56,5 +57,4 @@ describe Whois::Server::Adapters::Verisign do
       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" }]
+    @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

data/spec/whois/server_spec.rb

@@ -1,41 +1,43 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Whois::Server do
   describe ".load_json" do
     it "loads a definition from a JSON file" do
-      expect(File).to receive(:read).with("tld.json").and_return(<<-JSON)
-{
-  "ae.org": {
-    "host": "whois.centralnic.com"
-  },
-  "ar.com": {
-    "host": "whois.centralnic.com"
-  }
-}
+      expect(File).to receive(:read).with("tld.json").and_return(<<~JSON)
+        {
+          "ae.org": {
+            "host": "whois.centralnic.com"
+          },
+          "ar.com": {
+            "host": "whois.centralnic.com"
+          }
+        }
       JSON
       with_definitions do
         described_class.load_json("tld.json")
         expect(described_class.definitions(:tld)).to eq([
-          ["ae.org", "whois.centralnic.com", {}],
-          ["ar.com", "whois.centralnic.com", {}],
-        ])
+                                                          ["ae.org", "whois.centralnic.com", {}],
+                                                          ["ar.com", "whois.centralnic.com", {}],
+                                                        ])
       end
     end
 
     it "convert option keys to Symbol" do
-      expect(File).to receive(:read).with("tld.json").and_return(<<-JSON)
-{
-  "com": {
-    "host": "whois.crsnic.net",
-    "adapter": "verisign"
-  }
-}
+      expect(File).to receive(:read).with("tld.json").and_return(<<~JSON)
+        {
+          "com": {
+            "host": "whois.crsnic.net",
+            "adapter": "verisign"
+          }
+        }
       JSON
       with_definitions do
         described_class.load_json("tld.json")
         expect(described_class.definitions(:tld)).to eq([
-          ["com", "whois.crsnic.net", adapter: "verisign"],
-        ])
+                                                          ["com", "whois.crsnic.net", { adapter: "verisign" }],
+                                                        ])
       end
     end
   end
@@ -70,7 +72,7 @@ describe Whois::Server do
     it "accepts a hash of options" do
       with_definitions do
         Whois::Server.define(Whois::Server::TYPE_TLD, "foo", "whois.foo", foo: "bar")
-        expect(described_class.definitions(Whois::Server::TYPE_TLD)).to eq([["foo", "whois.foo", { :foo => "bar" }]])
+        expect(described_class.definitions(Whois::Server::TYPE_TLD)).to eq([["foo", "whois.foo", { foo: "bar" }]])
       end
     end
   end
@@ -81,7 +83,7 @@ describe Whois::Server do
       expect(server.type).to eq(:tld)
       expect(server.allocation).to eq("test")
       expect(server.host).to eq("whois.test")
-      expect(server.options).to eq(Hash.new)
+      expect(server.options).to eq({})
     end
 
     it "returns a standard adapter by default" do
@@ -92,25 +94,26 @@ describe Whois::Server do
     it "accepts an :adapter option as Class and returns an instance of given adapter" do
       a = Class.new do
         attr_reader :args
+
         def initialize(*args)
           @args = args
         end
       end
-      server = Whois::Server.factory(:tld, "test", "whois.test", :adapter => a)
+      server = Whois::Server.factory(:tld, "test", "whois.test", adapter: a)
       expect(server).to be_a(a)
       expect(server.args).to eq([:tld, "test", "whois.test", {}])
     end
 
     it "accepts an :adapter option as Symbol or String, load Class and returns an instance of given adapter" do
-      server = Whois::Server.factory(:tld, "test", "whois.test", :adapter => :none)
+      server = Whois::Server.factory(:tld, "test", "whois.test", adapter: :none)
       expect(server).to be_a(Whois::Server::Adapters::None)
-      server = Whois::Server.factory(:tld, "test", "whois.test", :adapter => "none")
+      server = Whois::Server.factory(:tld, "test", "whois.test", adapter: "none")
       expect(server).to be_a(Whois::Server::Adapters::None)
     end
 
     it "deletes the adapter option" do
-      server = Whois::Server.factory(:tld, "test", "whois.test", :adapter => Whois::Server::Adapters::None, :foo => "bar")
-      expect(server.options).to eq({ :foo => "bar" })
+      server = Whois::Server.factory(:tld, "test", "whois.test", adapter: Whois::Server::Adapters::None, foo: "bar")
+      expect(server.options).to eq({ foo: "bar" })
     end
   end
 
@@ -296,5 +299,4 @@ describe Whois::Server do
       end
     end
   end
-
 end