Cache mx_server_is_in? to speed up disposable_mx_server?

lib/valid_email2/address.rb

@@ -130,15 +130,7 @@ def domain_is_in?(domain_list)
     end
 
     def mx_server_is_in?(domain_list)
-      @dns.mx_servers(address.domain).any? { |mx_server|
-        return false unless mx_server.respond_to?(:exchange)
-
-        mx_server = mx_server.exchange.to_s
-
-        domain_list.any? { |domain|
-          mx_server.end_with?(domain) && mx_server =~ /\A(?:.+\.)*?#{domain}\z/
-        }
-      }
+      @dns.mx_servers_disposable?(address.domain, domain_list)
     end
 
     def address_contain_multibyte_characters?

lib/valid_email2/dns.rb

@@ -4,7 +4,7 @@ module ValidEmail2
   class Dns
     MAX_CACHE_SIZE = 1_000
     CACHE = {}
-
+    MX_SERVERS_CACHE = {}
     CacheEntry = Struct.new(:records, :cached_at, :ttl)
 
     def self.prune_cache
@@ -26,6 +26,26 @@ def mx_servers(domain)
       fetch(domain, Resolv::DNS::Resource::IN::MX)
     end
 
+    def mx_servers_disposable?(domain, domain_list)
+      servers = mx_servers(domain)
+      cache_key = generate_mx_cache_key(domain, domain_list, servers)
+      return MX_SERVERS_CACHE[cache_key] if !cache_key.nil? && MX_SERVERS_CACHE.key?(cache_key)
+
+      result = servers.any? do |mx_server|
+        return false unless mx_server.respond_to?(:exchange)
+
+        mx_server = mx_server.exchange.to_s
+
+        domain_list.any? do |disposable_domain|
+          mx_server.end_with?(disposable_domain) && mx_server.match?(/\A(?:.+\.)*?#{disposable_domain}\z/)
+        end
+      end
+
+      MX_SERVERS_CACHE[cache_key] = result unless cache_key.nil?
+
+      result
+    end
+
     def a_servers(domain)
       fetch(domain, Resolv::DNS::Resource::IN::A)
     end
@@ -67,5 +87,14 @@ def resolv_config
       config[:nameserver] = @dns_nameserver if @dns_nameserver
       config
     end
+
+    def generate_mx_cache_key(domain, domain_list, mx_servers)
+      return if mx_servers.empty? || domain_list.empty?
+
+      mx_servers_str = mx_servers.map(&:exchange).map(&:to_s).sort.join
+      return domain if mx_servers_str.empty?
+
+      "#{domain_list.object_id}_#{domain_list.length}_#{mx_servers_str.downcase}"
+    end
   end
 end

spec/address_spec.rb

@@ -111,14 +111,55 @@
     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)
       allow(Resolv::DNS).to receive(:open).and_yield(mock_resolv_dns)
       allow(mock_resolv_dns).to receive(:timeouts=)
     end
 
+    describe "#disposable_mx_server?" do
+      let(:disposable_email_address) { "[email protected]" }
+      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).not_to be_disposable_mx_server
+      end
+
+      it "is true if the MX server is in the disposable_emails list" do
+        expect(disposable_email_instance).to be_disposable_mx_server
+      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).not_to be_disposable_mx_server
+
+        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).to be_disposable_mx_server
+      end
+    end
+
     describe "#valid_strict_mx?" do
       let(:cached_at) { Time.now }
       let(:mock_cache_data) { { [email_instance.address.domain, Resolv::DNS::Resource::IN::MX] => ValidEmail2::Dns::CacheEntry.new(mock_mx_records, cached_at, ttl) } }
@@ -251,7 +292,7 @@
     describe "#valid_mx?" do
       let(:cached_at) { Time.now }
       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: 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)

spec/benchmark_spec.rb

@@ -5,14 +5,25 @@
 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("[email protected]")
 
     # 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.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("[email protected]")
+
+    # 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.disposable_mx_server? }.to perform_under(0.0001).sec.warmup(1).times.sample(10).times
   end
 end