valid_email2 7.0.0 → 7.0.11

data/gemfiles/activemodel8.gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem 'activemodel', '~> 8.0'
+
+gemspec path: '../'

data/lib/valid_email2/address.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal:true
 
 require "valid_email2"
-require "resolv"
 require "mail"
-require "valid_email2/dns_records_cache"
+require "valid_email2/dns"
 
 module ValidEmail2
   class Address
@@ -29,11 +28,10 @@ module ValidEmail2
       @permitted_multibyte_characters_regex = val
     end
 
-    def initialize(address, dns_timeout = 5, dns_nameserver = nil)
+    def initialize(address, dns = Dns.new)
       @parse_error = false
       @raw_address = address
-      @dns_timeout = dns_timeout
-      @dns_nameserver = dns_nameserver
+      @dns = dns
 
       begin
         @address = Mail::Address.new(address)
@@ -84,57 +82,54 @@ module ValidEmail2
     end
 
     def disposable_domain?
-      domain_is_in?(ValidEmail2.disposable_emails)
-    end
-
-    def disposable_mx_server?
-      valid? && mx_server_is_in?(ValidEmail2.disposable_emails)
+      domain_is_in?(address.domain, ValidEmail2.disposable_emails)
     end
 
     def allow_listed?
-      domain_is_in?(ValidEmail2.allow_list)
+      domain_is_in?(address.domain, ValidEmail2.allow_list)
     end
 
     def deny_listed?
-      valid? && domain_is_in?(ValidEmail2.deny_list)
+      valid? && domain_is_in?(address.domain, ValidEmail2.deny_list)
     end
 
     def valid_mx?
       return false unless valid?
       return false if null_mx?
 
-      mx_or_a_servers.any?
+      @dns.mx_servers(address.domain).any? || @dns.a_servers(address.domain).any?
     end
 
     def valid_strict_mx?
       return false unless valid?
       return false if null_mx?
 
-      mx_servers.any?
+      @dns.mx_servers(address.domain).any?
     end
 
     private
 
-    def domain_is_in?(domain_list)
-      address_domain = address.domain.downcase
-      return true if domain_list.include?(address_domain)
-
-      i = address_domain.index('.')
-      return false unless i
-
-      domain_list.include?(address_domain[(i + 1)..-1])
+    def disposable_mx_server?
+      address_domains = @dns.mx_servers(address.domain).map(&:exchange).map(&:to_s)
+      domain_is_in?(address_domains, ValidEmail2.disposable_emails)
     end
 
-    def mx_server_is_in?(domain_list)
-      mx_servers.any? { |mx_server|
-        return false unless mx_server.respond_to?(:exchange)
+    def domain_is_in?(address_domains, domain_list)
+      Array(address_domains).any? do |address_domain|
+        address_domain = address_domain.downcase
+        return true if domain_list.include?(address_domain)
 
-        mx_server = mx_server.exchange.to_s
+        tokens = address_domain.split('.')
+        return false if tokens.length < 3
 
-        domain_list.any? { |domain|
-          mx_server.end_with?(domain) && mx_server =~ /\A(?:.+\.)*?#{domain}\z/
-        }
-      }
+        # check only 6 elements deep
+        2.upto(6).each do |depth|
+          limited_sub_domain_part = tokens.reverse.first(depth).reverse.join('.')
+          return true if domain_list.include?(limited_sub_domain_part)
+        end
+
+        false
+      end
     end
 
     def address_contain_multibyte_characters?
@@ -145,41 +140,9 @@ module ValidEmail2
       @raw_address.each_char.any? { |char| char.bytesize > 1 && char !~ self.class.permitted_multibyte_characters_regex }
     end
 
-    def resolv_config
-      @resolv_config ||= begin
-        config = Resolv::DNS::Config.default_config_hash
-        config[:nameserver] = @dns_nameserver if @dns_nameserver
-        config
-      end
-
-      @resolv_config
-    end
-
-    def mx_servers
-      @mx_servers_cache ||= ValidEmail2::DnsRecordsCache.new
-
-      @mx_servers_cache.fetch(address.domain.downcase) do
-        Resolv::DNS.open(resolv_config) do |dns|
-          dns.timeouts = @dns_timeout
-          dns.getresources(address.domain, Resolv::DNS::Resource::IN::MX)
-        end
-      end
-    end
-
     def null_mx?
+      mx_servers = @dns.mx_servers(address.domain)
       mx_servers.length == 1 && mx_servers.first.preference == 0 && mx_servers.first.exchange.length == 0
     end
-
-    def mx_or_a_servers
-      @mx_or_a_servers_cache ||= ValidEmail2::DnsRecordsCache.new
-
-      @mx_or_a_servers_cache.fetch(address.domain.downcase) do
-        Resolv::DNS.open(resolv_config) do |dns|
-          dns.timeouts = @dns_timeout
-          (mx_servers.any? && mx_servers) ||
-            dns.getresources(address.domain, Resolv::DNS::Resource::IN::A)
-        end
-      end
-    end
   end
 end

data/lib/valid_email2/dns.rb

@@ -0,0 +1,71 @@
+require "resolv"
+
+module ValidEmail2
+  class Dns
+    MAX_CACHE_SIZE = 1_000
+    CACHE = {}
+
+    CacheEntry = Struct.new(:records, :cached_at, :ttl)
+
+    def self.prune_cache
+      entries_sorted_by_cached_at_asc = CACHE.sort_by { |key, data| data.cached_at }
+      entries_to_remove = entries_sorted_by_cached_at_asc.first(CACHE.size - MAX_CACHE_SIZE)
+      entries_to_remove.each { |key, _value| CACHE.delete(key) }
+    end
+
+    def self.clear_cache
+      CACHE.clear
+    end
+
+    def initialize(dns_timeout = 5, dns_nameserver = nil)
+      @dns_timeout = dns_timeout
+      @dns_nameserver = dns_nameserver
+    end
+
+    def mx_servers(domain)
+      fetch(domain, Resolv::DNS::Resource::IN::MX)
+    end
+
+    def a_servers(domain)
+      fetch(domain, Resolv::DNS::Resource::IN::A)
+    end
+
+    private
+
+    def prune_cache
+      self.class.prune_cache
+    end
+
+    def fetch(domain, type)
+      prune_cache if CACHE.size > MAX_CACHE_SIZE
+
+      domain = domain.downcase
+      cache_key = [domain, type]
+      cache_entry = CACHE[cache_key]
+
+      if cache_entry && Time.now - cache_entry.cached_at < cache_entry.ttl
+        return cache_entry.records
+      else
+        CACHE.delete(cache_key)
+      end
+
+      records = Resolv::DNS.open(resolv_config) do |dns|
+        dns.timeouts = @dns_timeout
+        dns.getresources(domain, type)
+      end
+
+      if records.any?
+        ttl = records.map(&:ttl).min
+        CACHE[cache_key] = CacheEntry.new(records, Time.now, ttl)
+      end
+
+      records
+    end
+
+    def resolv_config
+      config = Resolv::DNS::Config.default_config_hash
+      config[:nameserver] = @dns_nameserver if @dns_nameserver
+      config
+    end
+  end
+end

data/lib/valid_email2/email_validator.rb

@@ -1,4 +1,5 @@
 require "valid_email2/address"
+require "logger" # Fix concurrent-ruby removing logger dependency which Rails itself does not have
 require "active_model"
 require "active_model/validations"
 
@@ -12,7 +13,8 @@ module ValidEmail2
       return unless value.present?
       options = default_options.merge(self.options)
 
-      addresses = sanitized_values(value).map { |v| ValidEmail2::Address.new(v, options[:dns_timeout], options[:dns_nameserver]) }
+      dns = ValidEmail2::Dns.new(options[:dns_timeout], options[:dns_nameserver])
+      addresses = sanitized_values(value).map { |v| ValidEmail2::Address.new(v, dns) }
 
       error(record, attribute) && return unless addresses.all?(&:valid?)
 

data/lib/valid_email2/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal:true
 
 module ValidEmail2
-  VERSION = "7.0.0"
+  VERSION = "7.0.11"
 end

data/pull_mailchecker_emails.rb

@@ -29,6 +29,16 @@ remote_emails = [
   resp.body.split("\n").flatten
 end
 
-result_emails = (existing_emails + remote_emails).map(&:strip).uniq.sort - allow_listed_emails
-
-File.write("config/disposable_email_domains.txt", result_emails.join("\n"))
+deny_listed_tlds = %w[me ml id]
+
+result_emails = (existing_emails + remote_emails).map(&:strip) - allow_listed_emails
+result_emails = result_emails.map do |line|
+  ts = line.chomp.split(".")
+  if ts.last.size == 2 && !deny_listed_tlds.include?(ts.last)
+    ts.last(3).join(".")
+  else
+    ts.last(2).join(".")
+  end
+end.uniq.sort
+
+File.open("config/disposable_email_domains.txt", "w") { |f| f.puts(result_emails) }

data/spec/address_spec.rb

@@ -3,6 +3,10 @@
 require "spec_helper"
 
 describe ValidEmail2::Address do
+  before do
+    ValidEmail2::Dns.clear_cache
+  end
+
   describe "#valid?" do
     it "is valid" do
       address = described_class.new("foo@bar123.com")
@@ -51,18 +55,63 @@ describe ValidEmail2::Address do
 
       it "is valid if it contains special scandinavian characters" do
         address = described_class.new("jørgen@email.dk")
-        expect(address.valid?).to eq true
+        expect(address.valid?).to be_truthy
+      end
+    end
+  end
+
+  describe "#disposable_domain?" do
+    context "when the disposable domain does not have subdomains" do
+      let(:disposable_domain) { ValidEmail2.disposable_emails.select { |domain| domain.count(".") == 1 }.sample }
+
+      it "is true if the domain is in the disposable_emails list" do
+        address = described_class.new("foo@#{disposable_domain}")
+        expect(address.disposable_domain?).to be_truthy
+      end
+
+      it "is true if the domain is a subdomain of a disposable domain" do
+        address = described_class.new("foo@sub.#{disposable_domain}")
+        expect(address.disposable_domain?).to be_truthy
+      end
+
+      it "is true if the domain is a deeply nested subdomain of a disposable domain" do
+        address = described_class.new("foo@sub3.sub2.sub1.#{disposable_domain}")
+        expect(address.disposable_domain?).to be_truthy
+      end
+
+      it "is false if the domain is not in the disposable_emails list" do
+        address = described_class.new("foo@example.com")
+        expect(address.disposable_domain?).to eq false
+      end
+    end
+
+    context "when the disposable domain has subdomains" do
+      let(:disposable_domain) { ValidEmail2.disposable_emails.select { |domain| domain.count(".") > 1 }.sample }
+
+      it "is true if the domain is in the disposable_emails list" do
+        address = described_class.new("foo@#{disposable_domain}")
+        expect(address.disposable_domain?).to be_truthy
+      end
+
+      it "is true if the domain is a subdomain of a disposable domain" do
+        address = described_class.new("foo@sub.#{disposable_domain}")
+        expect(address.disposable_domain?).to be_truthy
+      end
+
+      it "is true if the domain is a deeply nested subdomain of a disposable domain" do
+        address = described_class.new("foo@sub3.sub2.sub1.#{disposable_domain}")
+        expect(address.disposable_domain?).to be_truthy
       end
     end
   end
 
   describe "caching" do
     let(:email_address) { "example@ymail.com" }
-    let(:email_instance) { described_class.new(email_address) }
-    let(:dns_records_cache_instance) { ValidEmail2::DnsRecordsCache.new }
+    let(:dns_instance) { ValidEmail2::Dns.new }
+    let(:email_instance) { described_class.new(email_address, dns_instance) }
     let(:ttl) { 1_000 }
     let(:mock_resolv_dns) { instance_double(Resolv::DNS) }
-    let(:mock_mx_records) { [double("MX", exchange: "mx.ymail.com", preference: 10, ttl: ttl)] }
+    let(:mock_mx_records) { [double("MX", exchange: "mx.ymail.com", preference: 10, ttl:)] }
 
     before do
       allow(email_instance).to receive(:null_mx?).and_return(false)
@@ -70,9 +119,50 @@ describe ValidEmail2::Address do
       allow(mock_resolv_dns).to receive(:timeouts=)
     end
 
+    describe "#disposable_mx_server?" do
+      let(:disposable_email_address) { "example@10minutemail.com" }
+      let(:disposable_mx_server) { ValidEmail2.disposable_emails.select { |domain| domain.count(".") == 1 }.sample }
+      let(:disposable_email_instance) { described_class.new(disposable_email_address, dns_instance) }
+      let(:mock_disposable_mx_records) { [double("MX", exchange: "mx.#{disposable_mx_server}", preference: 10, ttl:)] }
+
+      before do
+        allow(mock_resolv_dns).to receive(:getresources)
+          .with(disposable_email_instance.address.domain, Resolv::DNS::Resource::IN::MX)
+          .and_return(mock_disposable_mx_records)
+
+        allow(mock_resolv_dns).to receive(:getresources)
+          .with(email_instance.address.domain, Resolv::DNS::Resource::IN::MX)
+          .and_return(mock_mx_records)
+      end
+
+      it "is false if the MX server is not in the disposable_emails list" do
+        expect(email_instance.send(:disposable_mx_server?)).not_to be_truthy
+      end
+
+      it "is true if the MX server is in the disposable_emails list" do
+        expect(disposable_email_instance.send(:disposable_mx_server?)).to be_truthy
+      end
+
+      it "is false and then true when the MX record changes from non-disposable to disposable" do
+        allow(mock_resolv_dns).to receive(:getresources)
+          .with(disposable_email_instance.address.domain, Resolv::DNS::Resource::IN::MX)
+          .and_return(mock_mx_records) # non-disposable MX records
+
+        expect(disposable_email_instance.send(:disposable_mx_server?)).not_to be_truthy
+
+        ValidEmail2::Dns.clear_cache
+
+        allow(mock_resolv_dns).to receive(:getresources)
+          .with(disposable_email_instance.address.domain, Resolv::DNS::Resource::IN::MX)
+          .and_return(mock_disposable_mx_records) # disposable MX records
+
+        expect(disposable_email_instance.send(:disposable_mx_server?)).to be_truthy
+      end
+    end
+
     describe "#valid_strict_mx?" do
       let(:cached_at) { Time.now }
-      let(:mock_cache_data) { { email_instance.address.domain => { records: mock_mx_records, cached_at: cached_at, ttl: ttl } } }
+      let(:mock_cache_data) { { [email_instance.address.domain, Resolv::DNS::Resource::IN::MX] => ValidEmail2::Dns::CacheEntry.new(mock_mx_records, cached_at, ttl) } }
 
       before do
         allow(mock_resolv_dns).to receive(:getresources)
@@ -108,9 +198,9 @@ describe ValidEmail2::Address do
 
       describe "ttl" do
         before do
-          dns_records_cache_instance.instance_variable_set(:@cache, mock_cache_data)
-          allow(ValidEmail2::DnsRecordsCache).to receive(:new).and_return(dns_records_cache_instance)
-          allow(dns_records_cache_instance).to receive(:fetch).with(email_instance.address.domain).and_call_original
+          stub_const("ValidEmail2::Dns::CACHE", mock_cache_data)
+          allow(ValidEmail2::Dns).to receive(:new).and_return(dns_instance)
+          allow(dns_instance).to receive(:fetch).with(email_instance.address.domain, Resolv::DNS::Resource::IN::MX).and_call_original
         end
 
         context "when the time since last lookup is less than the cached ttl entry" do
@@ -136,18 +226,18 @@ describe ValidEmail2::Address do
 
       describe "cache size" do
         before do
-          dns_records_cache_instance.instance_variable_set(:@cache, mock_cache_data)
-          allow(ValidEmail2::DnsRecordsCache).to receive(:new).and_return(dns_records_cache_instance)
-          allow(dns_records_cache_instance).to receive(:fetch).with(email_instance.address.domain).and_call_original
+          stub_const("ValidEmail2::Dns::CACHE", mock_cache_data)
+          allow(ValidEmail2::Dns).to receive(:new).and_return(dns_instance)
+          allow(dns_instance).to receive(:fetch).with(email_instance.address.domain, Resolv::DNS::Resource::IN::MX).and_call_original
         end
 
         context "when the cache size is less than or equal to the max cache size" do
           before do
-            stub_const("ValidEmail2::DnsRecordsCache::MAX_CACHE_SIZE", 1)
+            stub_const("ValidEmail2::Dns::MAX_CACHE_SIZE", 1)
           end
 
           it "does not prune the cache" do
-            expect(dns_records_cache_instance).not_to receive(:prune_cache)
+            expect(dns_instance).not_to receive(:prune_cache)
 
             email_instance.valid_strict_mx?
           end
@@ -159,42 +249,40 @@ describe ValidEmail2::Address do
           end
 
           context "and there are older cached entries" do
-            let(:mock_cache_data) { { "another_domain.com" => { records: mock_mx_records, cached_at: cached_at - 100, ttl: ttl } } }
+            let(:mock_cache_data) { { ["another_domain.com", Resolv::DNS::Resource::IN::MX] => ValidEmail2::Dns::CacheEntry.new(mock_mx_records, cached_at - 100, ttl) } }
 
             it "does not prune those entries" do
               email_instance.valid_strict_mx?
 
-              expect(dns_records_cache_instance.instance_variable_get(:@cache).keys.size).to eq 2
-              expect(dns_records_cache_instance.instance_variable_get(:@cache).keys).to match_array([email_instance.address.domain, "another_domain.com"])
+              expect(ValidEmail2::Dns::CACHE.keys).to match_array([[email_instance.address.domain, Resolv::DNS::Resource::IN::MX], ["another_domain.com", Resolv::DNS::Resource::IN::MX]])
             end
           end
         end
 
         context "when the cache size is greater than the max cache size" do
           before do
-            stub_const("ValidEmail2::DnsRecordsCache::MAX_CACHE_SIZE", 0)
+            stub_const("ValidEmail2::Dns::MAX_CACHE_SIZE", 0)
           end
 
           it "prunes the cache" do
-            expect(dns_records_cache_instance).to receive(:prune_cache).once
+            expect(dns_instance).to receive(:prune_cache).once
 
             email_instance.valid_strict_mx?
           end
 
-          it "calls the the MX servers lookup" do    
+          it "calls the the MX servers lookup" do
             email_instance.valid_strict_mx?
 
             expect(Resolv::DNS).to have_received(:open).once
           end
 
           context "and there are older cached entries" do
-            let(:mock_cache_data) { { "another_domain.com" => { records: mock_mx_records, cached_at: cached_at - 100, ttl: ttl } } }
+            let(:mock_cache_data) { { ["another_domain.com", Resolv::DNS::Resource::IN::MX] => ValidEmail2::Dns::CacheEntry.new(mock_mx_records, cached_at - 100, ttl) } }
 
             it "prunes those entries" do
               email_instance.valid_strict_mx?
 
-              expect(dns_records_cache_instance.instance_variable_get(:@cache).keys.size).to eq 1
-              expect(dns_records_cache_instance.instance_variable_get(:@cache).keys).to match_array([email_instance.address.domain])
+              expect(ValidEmail2::Dns::CACHE.keys).to match_array([[email_instance.address.domain, Resolv::DNS::Resource::IN::MX]])
             end
           end
         end
@@ -203,13 +291,13 @@ describe ValidEmail2::Address do
 
     describe "#valid_mx?" do
       let(:cached_at) { Time.now }
-      let(:mock_cache_data) { { email_instance.address.domain => { records: mock_a_records, cached_at: cached_at, ttl: ttl } } }
-      let(:mock_a_records) { [double("A", address: "192.168.1.1", ttl: ttl)] }
+      let(:mock_cache_data) { { [email_instance.address.domain, Resolv::DNS::Resource::IN::MX] => ValidEmail2::Dns::CacheEntry.new(mock_a_records, cached_at, ttl) } }
+      let(:mock_a_records) { [double("A", address: "192.168.1.1", ttl:)] }
 
       before do
         allow(email_instance).to receive(:mx_servers).and_return(mock_mx_records)
         allow(mock_resolv_dns).to receive(:getresources)
-          .with(email_instance.address.domain, Resolv::DNS::Resource::IN::A)
+          .with(email_instance.address.domain, Resolv::DNS::Resource::IN::MX)
           .and_return(mock_a_records)
       end
 
@@ -241,9 +329,9 @@ describe ValidEmail2::Address do
 
       describe "ttl" do
         before do
-          dns_records_cache_instance.instance_variable_set(:@cache, mock_cache_data)
-          allow(ValidEmail2::DnsRecordsCache).to receive(:new).and_return(dns_records_cache_instance)
-          allow(dns_records_cache_instance).to receive(:fetch).with(email_instance.address.domain).and_call_original
+          stub_const("ValidEmail2::Dns::CACHE", mock_cache_data)
+          allow(ValidEmail2::Dns).to receive(:new).and_return(dns_instance)
+          allow(dns_instance).to receive(:fetch).with(email_instance.address.domain, Resolv::DNS::Resource::IN::MX).and_call_original
         end
 
         context "when the time since last lookup is less than the cached ttl entry" do
@@ -269,14 +357,14 @@ describe ValidEmail2::Address do
 
       describe "cache size" do
         before do
-          dns_records_cache_instance.instance_variable_set(:@cache, mock_cache_data)
-          allow(ValidEmail2::DnsRecordsCache).to receive(:new).and_return(dns_records_cache_instance)
-          allow(dns_records_cache_instance).to receive(:fetch).with(email_instance.address.domain).and_call_original
+          stub_const("ValidEmail2::Dns::CACHE", mock_cache_data)
+          allow(ValidEmail2::Dns).to receive(:new).and_return(dns_instance)
+          allow(dns_instance).to receive(:fetch).with(email_instance.address.domain, Resolv::DNS::Resource::IN::MX).and_call_original
         end
 
         context "when the cache size is less than or equal to the max cache size" do
           before do
-            stub_const("ValidEmail2::DnsRecordsCache::MAX_CACHE_SIZE", 1)
+            stub_const("ValidEmail2::Dns::MAX_CACHE_SIZE", 1)
           end
 
           it "does not prune the cache" do
@@ -292,24 +380,23 @@ describe ValidEmail2::Address do
           end
 
           context "and there are older cached entries" do
-            let(:mock_cache_data) { { "another_domain.com" => { records: mock_a_records, cached_at: cached_at - 100, ttl: ttl } } }
+            let(:mock_cache_data) { { ["another_domain.com", Resolv::DNS::Resource::IN::MX] => ValidEmail2::Dns::CacheEntry.new(mock_a_records, cached_at - 100, ttl) } }
 
             it "does not prune those entries" do
               email_instance.valid_mx?
 
-              expect(dns_records_cache_instance.instance_variable_get(:@cache).keys.size).to eq 2
-              expect(dns_records_cache_instance.instance_variable_get(:@cache).keys).to match_array([email_instance.address.domain, "another_domain.com"])
+              expect(ValidEmail2::Dns::CACHE.keys).to match_array([[email_instance.address.domain, Resolv::DNS::Resource::IN::MX], ["another_domain.com", Resolv::DNS::Resource::IN::MX]])
             end
           end
         end
 
         context "when the cache size is greater than the max cache size" do
           before do
-            stub_const("ValidEmail2::DnsRecordsCache::MAX_CACHE_SIZE", 0)
+            stub_const("ValidEmail2::Dns::MAX_CACHE_SIZE", 0)
           end
 
-          it "prunes the cache" do 
-            expect(dns_records_cache_instance).to receive(:prune_cache).once 
+          it "prunes the cache" do
+            expect(dns_instance).to receive(:prune_cache).once
 
             email_instance.valid_mx?
           end
@@ -321,17 +408,16 @@ describe ValidEmail2::Address do
           end
 
           context "and there are older cached entries" do
-            let(:mock_cache_data) { { "another_domain.com" => { records: mock_a_records, cached_at: cached_at - 100, ttl: ttl } } }
+            let(:mock_cache_data) { { ["another_domain.com", Resolv::DNS::Resource::IN::MX] => ValidEmail2::Dns::CacheEntry.new(mock_a_records, cached_at - 100, ttl) } }
 
             it "prunes those entries" do
               email_instance.valid_mx?
 
-              expect(dns_records_cache_instance.instance_variable_get(:@cache).keys.size).to eq 1
-              expect(dns_records_cache_instance.instance_variable_get(:@cache).keys).to match_array([email_instance.address.domain])
+              expect(ValidEmail2::Dns::CACHE.keys).to match_array([[email_instance.address.domain, Resolv::DNS::Resource::IN::MX]])
             end
           end
         end
-      end    
+      end
     end
   end
 end

data/spec/benchmark_spec.rb

@@ -5,7 +5,7 @@ require "spec_helper"
 describe "Performance testing" do
   let(:disposable_domain) { ValidEmail2.disposable_emails.first }
 
-  it "has acceptable lookup performance" do
+  it "disposable_domain? has acceptable lookup performance" do
     address = ValidEmail2::Address.new("test@example.com")
 
     # preload list and check size
@@ -13,6 +13,17 @@ describe "Performance testing" do
     expect(ValidEmail2.disposable_emails.count).to be > 30000
 
     # check lookup timing
-    expect { address.disposable_domain? }.to perform_under(0.0001).sample(10).times
+    expect { address.disposable_domain? }.to perform_under(0.0001).sec.sample(10).times
+  end
+
+  it "disposable_mx_server? has acceptable lookup performance" do
+    address = ValidEmail2::Address.new("test@gmail.com")
+
+    # preload list and check size
+    expect(ValidEmail2.disposable_emails).to be_a(Set)
+    expect(ValidEmail2.disposable_emails.count).to be > 30000
+
+    # check lookup timing
+    expect { address.send(:disposable_mx_server?) }.to perform_under(0.00015).sec.sample(10).times
   end
 end

data/spec/dns_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe ValidEmail2::Dns do
+  describe "#mx_servers" do
+    it "gets a record" do
+      dns = described_class.new
+      records = dns.mx_servers("gmail.com")
+      expect(records.size).to_not be_zero
+    end
+  end
+
+  describe "#a_servers" do
+    it "gets a record" do
+      dns = described_class.new
+      records = dns.a_servers("gmail.com")
+      expect(records.size).to_not be_zero
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 $:.unshift File.expand_path("../lib",__FILE__)
 require "valid_email2"
+require "debug"
 
 # Include and configure  benchmark
 require 'rspec-benchmark'

data/spec/valid_email2_spec.rb

@@ -76,6 +76,9 @@ class TestUserMultiple < TestModel
 end
 
 describe ValidEmail2 do
+  before do
+    ValidEmail2::Dns.clear_cache
+  end
 
   let(:disposable_domain) { ValidEmail2.disposable_emails.first }