truemail 2.1.0 → 2.3.0

data/lib/truemail.rb

@@ -10,7 +10,7 @@ module Truemail
   class << self
     def configuration(&block)
       @configuration ||= begin
-        return unless block_given?
+        return unless block
         configuration = Truemail::Configuration.new(&block)
         raise_unless(configuration.complete?, Truemail::INCOMPLETE_CONFIG)
         configuration
@@ -46,7 +46,7 @@ module Truemail
     end
 
     def check_argument_type(argument)
-      raise_unless(argument.is_a?(String), Truemail::INVALID_TYPE, Truemail::TypeError)
+      raise_unless(argument.is_a?(::String), Truemail::INVALID_TYPE, Truemail::TypeError)
     end
 
     def determine_configuration(custom_configuration)

data/lib/truemail/audit/base.rb

@@ -5,7 +5,6 @@ module Truemail
     class Base < Truemail::Worker
       require 'net/http'
       require 'ipaddr'
-      require 'resolv'
 
       private
 

data/lib/truemail/audit/dns.rb

@@ -14,7 +14,7 @@ module Truemail
 
       def a_record
         Truemail::Wrapper.call(configuration: configuration) do
-          Resolv::DNS.new.getaddress(verifier_domain).to_s
+          Truemail::Dns::Resolver.a_record(verifier_domain, configuration: configuration)
         end
       end
 

data/lib/truemail/audit/ip.rb

@@ -15,7 +15,7 @@ module Truemail
       private
 
       def detect_ip_via_ipify
-        Net::HTTP.get(URI(Truemail::Audit::Ip::GET_MY_IP_URL))
+        ::Net::HTTP.get(URI(Truemail::Audit::Ip::GET_MY_IP_URL))
       end
 
       def detect_current_host_ip

data/lib/truemail/audit/ptr.rb

@@ -15,13 +15,14 @@ module Truemail
       private
 
       def current_host_reverse_lookup
-        IPAddr.new(current_host_ip).reverse
+        ::IPAddr.new(current_host_ip).reverse
       end
 
       def ptr_records
         @ptr_records ||= Truemail::Wrapper.call(configuration: configuration) do
-          Resolv::DNS.new.getresources(
-            current_host_reverse_lookup, Resolv::DNS::Resource::IN::PTR
+          Truemail::Dns::Resolver.ptr_records(
+            current_host_reverse_lookup,
+            configuration: configuration
           ).map { |ptr_record| ptr_record.name.to_s }
         end || []
       end

data/lib/truemail/auditor.rb

@@ -2,7 +2,7 @@
 
 module Truemail
   class Auditor < Truemail::Executor
-    Result = Struct.new(:current_host_ip, :warnings, :configuration, keyword_init: true) do
+    Result = ::Struct.new(:current_host_ip, :warnings, :configuration, keyword_init: true) do
       def initialize(warnings: {}, **args)
         super
       end

data/lib/truemail/configuration.rb

@@ -7,34 +7,31 @@ module Truemail
     DEFAULT_CONNECTION_ATTEMPTS = 2
     DEFAULT_VALIDATION_TYPE = :smtp
     DEFAULT_LOGGER_OPTIONS = { tracking_event: :error, stdout: false, log_absolute_path: nil }.freeze
-
-    attr_reader :email_pattern,
-                :smtp_error_body_pattern,
-                :verifier_email,
+    SETTERS = %i[
+      email_pattern
+      smtp_error_body_pattern
+      connection_timeout
+      response_timeout
+      connection_attempts
+      whitelisted_domains
+      blacklisted_domains
+    ].freeze
+
+    attr_reader :verifier_email,
                 :verifier_domain,
-                :connection_timeout,
-                :response_timeout,
-                :connection_attempts,
                 :default_validation_type,
                 :validation_type_by_domain,
-                :whitelisted_domains,
-                :blacklisted_domains,
-                :logger
+                :dns,
+                :logger,
+                *Truemail::Configuration::SETTERS
 
-    attr_accessor :whitelist_validation, :not_rfc_mx_lookup_flow, :smtp_safe_check
+    attr_accessor :whitelist_validation, :not_rfc_mx_lookup_flow, :smtp_fail_fast, :smtp_safe_check
 
     def initialize(&block)
       instance_initializer.each do |instace_variable, value|
         instance_variable_set(:"@#{instace_variable}", value)
       end
-      tap(&block) if block_given?
-    end
-
-    %i[email_pattern smtp_error_body_pattern].each do |method|
-      define_method("#{method}=") do |argument|
-        raise_unless(argument, __method__, argument.is_a?(Regexp))
-        instance_variable_set(:"@#{method}", argument)
-      end
+      tap(&block) if block
     end
 
     def verifier_email=(email)
@@ -48,15 +45,8 @@ module Truemail
       @verifier_domain = domain.downcase
     end
 
-    %i[connection_timeout response_timeout connection_attempts].each do |method|
-      define_method("#{method}=") do |argument|
-        raise_unless(argument, __method__, argument.is_a?(Integer) && argument.positive?)
-        instance_variable_set(:"@#{method}", argument)
-      end
-    end
-
     def default_validation_type=(argument)
-      raise_unless(argument, __method__, argument.is_a?(Symbol) && Truemail::Validator::VALIDATION_TYPES.include?(argument))
+      raise_unless(argument, __method__, argument.is_a?(::Symbol) && Truemail::Validator::VALIDATION_TYPES.include?(argument))
       @default_validation_type = argument
     end
 
@@ -65,18 +55,31 @@ module Truemail
       validation_type_by_domain.merge!(settings)
     end
 
-    %i[whitelisted_domains blacklisted_domains].each do |method|
+    def argument_consistent?(argument)
+      case argument
+      when ::Array then check_domain_list(argument)
+      when ::Integer then argument.positive?
+      when ::Regexp then true
+      end
+    end
+
+    Truemail::Configuration::SETTERS.each do |method|
       define_method("#{method}=") do |argument|
-        raise_unless(argument, __method__, argument.is_a?(Array) && check_domain_list(argument))
+        raise_unless(argument, __method__, argument_consistent?(argument))
         instance_variable_set(:"@#{method}", argument)
       end
     end
 
+    def dns=(argument)
+      raise_unless(argument, __method__, argument.is_a?(::Array) && check_dns_settings(argument))
+      @dns = argument
+    end
+
     def logger=(options)
       tracking_event, stdout, log_absolute_path = logger_options(options)
       valid_event = Truemail::Log::Event::TRACKING_EVENTS.key?(tracking_event)
       stdout_only = stdout && log_absolute_path.nil?
-      file_only = log_absolute_path.is_a?(String)
+      file_only = log_absolute_path.is_a?(::String)
       both_types = stdout && file_only
       argument_info = valid_event ? log_absolute_path : tracking_event
       raise_unless(argument_info, __method__, valid_event && (stdout_only || file_only || both_types))
@@ -89,7 +92,7 @@ module Truemail
 
     private
 
-    def instance_initializer
+    def instance_initializer # rubocop:disable Metrics/MethodLength
       {
         email_pattern: Truemail::RegexConstant::REGEX_EMAIL_PATTERN,
         smtp_error_body_pattern: Truemail::RegexConstant::REGEX_SMTP_ERROR_BODY_PATTERN,
@@ -101,7 +104,9 @@ module Truemail
         whitelisted_domains: [],
         whitelist_validation: false,
         blacklisted_domains: [],
+        dns: [],
         not_rfc_mx_lookup_flow: false,
+        smtp_fail_fast: false,
         smtp_safe_check: false
       }
     end
@@ -136,13 +141,17 @@ module Truemail
     end
 
     def validate_validation_type(settings)
-      raise_unless(settings, 'hash with settings', settings.is_a?(Hash))
+      raise_unless(settings, 'hash with settings', settings.is_a?(::Hash))
       settings.each do |domain, validation_type|
         check_domain(domain)
         check_validation_type(validation_type)
       end
     end
 
+    def check_dns_settings(dns_servers)
+      dns_servers.all? { |dns_server| Truemail::RegexConstant::REGEX_DNS_SERVER_ADDRESS_PATTERN.match?(dns_server.to_s) }
+    end
+
     def logger_options(current_options)
       Truemail::Configuration::DEFAULT_LOGGER_OPTIONS.merge(current_options).values
     end

data/lib/truemail/core.rb

@@ -10,32 +10,28 @@ module Truemail
   require_relative '../truemail/validator'
   require_relative '../truemail/logger'
 
-  ConfigurationError = Class.new(StandardError)
-  TypeError = Class.new(StandardError)
-
-  ArgumentError = Class.new(StandardError) do
+  ConfigurationError = ::Class.new(::StandardError)
+  TypeError = ::Class.new(::StandardError)
+  ArgumentError = ::Class.new(::StandardError) do
     def initialize(arg_value, arg_name)
       super("#{arg_value} is not a valid #{arg_name}")
     end
   end
 
-  PunycodeRepresenter = Class.new do
-    require 'simpleidn'
-
-    def self.call(email)
-      return unless email.is_a?(String)
-      return email if email.ascii_only?
-      user, domain = email.split('@')
-      "#{user}@#{SimpleIDN.to_ascii(domain.downcase)}"
-    end
-  end
-
   module RegexConstant
     REGEX_DOMAIN = /[\p{L}0-9]+([\-.]{1}[\p{L}0-9]+)*\.\p{L}{2,63}/i.freeze
     REGEX_EMAIL_PATTERN = /(?=\A.{6,255}\z)(\A([\p{L}0-9]+[\w|\-.+]*)@(#{REGEX_DOMAIN})\z)/.freeze
     REGEX_DOMAIN_PATTERN = /(?=\A.{4,255}\z)(\A#{REGEX_DOMAIN}\z)/.freeze
     REGEX_DOMAIN_FROM_EMAIL = /\A.+@(.+)\z/.freeze
     REGEX_SMTP_ERROR_BODY_PATTERN = /(?=.*550)(?=.*(user|account|customer|mailbox)).*/i.freeze
+    REGEX_PORT_NUMBER = /(6553[0-5]|655[0-2][0-9]\d|65[0-4](\d){2}|6[0-4](\d){3}|[1-5](\d){4}|[1-9](\d){0,3})/.freeze
+    REGEX_DNS_SERVER_ADDRESS_PATTERN = /\A((1\d|[1-9]|2[0-4])?\d|25[0-5])(\.\g<1>){3}(:#{REGEX_PORT_NUMBER})?\z/.freeze
+  end
+
+  module Dns
+    require_relative '../truemail/dns/punycode_representer'
+    require_relative '../truemail/dns/worker'
+    require_relative '../truemail/dns/resolver'
   end
 
   module Audit

data/lib/truemail/dns/punycode_representer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Truemail
+  module Dns
+    PunycodeRepresenter = Class.new do
+      require 'simpleidn'
+
+      def self.call(email)
+        return unless email.is_a?(::String)
+        return email if email.ascii_only?
+        user, domain = email.split('@')
+        "#{user}@#{SimpleIDN.to_ascii(domain.downcase)}"
+      end
+    end
+  end
+end

data/lib/truemail/dns/resolver.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Truemail
+  module Dns
+    class Resolver
+      WORKER_ACTIONS = %i[dns_lookup a_record a_records cname_records mx_records ptr_records].freeze
+
+      class << self
+        Truemail::Dns::Resolver::WORKER_ACTIONS.each do |worker_action|
+          define_method(worker_action) do |argument, configuration:|
+            Truemail::Dns::Worker.new(configuration.dns).public_send(worker_action, argument)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/truemail/dns/worker.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Truemail
+  module Dns
+    require 'resolv'
+
+    class Worker < ::Resolv::DNS
+      DEFAULT_DNS_PORT = 53
+
+      attr_reader :dns_gateway
+
+      def initialize(dns_servers)
+        super(dns_servers.empty? ? nil : config_info(dns_servers))
+      end
+
+      def dns_lookup(host_address)
+        getname(host_address).to_s
+      end
+
+      def a_record(host_name)
+        getaddress(host_name).to_s
+      end
+
+      def a_records(host_name)
+        getaddresses(host_name).map(&:to_s)
+      end
+
+      def cname_records(host_name)
+        getresources(host_name, ::Resolv::DNS::Resource::IN::CNAME)
+      end
+
+      def mx_records(host_name)
+        getresources(host_name, ::Resolv::DNS::Resource::IN::MX)
+      end
+
+      def ptr_records(host_address)
+        getresources(host_address, ::Resolv::DNS::Resource::IN::PTR)
+      end
+
+      private
+
+      def nameserver_port(server)
+        server_address, server_port = server.split(':')
+        [server_address, server_port ? server_port.to_i : Truemail::Dns::Worker::DEFAULT_DNS_PORT]
+      end
+
+      def config_info(dns_servers)
+        @dns_gateway = { nameserver_port: dns_servers.map { |server| nameserver_port(server) } }
+      end
+    end
+  end
+end

data/lib/truemail/log/serializer/auditor_json.rb

@@ -13,7 +13,7 @@ module Truemail
         def result
           @result ||=
             {
-              date: Time.now,
+              date: ::Time.now,
               current_host_ip: executor_result.current_host_ip,
               warnings: warnings(executor_result.warnings),
               configuration: configuration

data/lib/truemail/log/serializer/base.rb

@@ -30,7 +30,7 @@ module Truemail
 
         alias warnings errors
 
-        %i[validation_type_by_domain whitelisted_domains blacklisted_domains].each do |method|
+        %i[validation_type_by_domain whitelisted_domains blacklisted_domains dns].each do |method|
           define_method(method) do
             value = executor_configuration.public_send(method)
             return if value.empty?
@@ -55,7 +55,9 @@ module Truemail
             whitelist_validation: executor_configuration.whitelist_validation,
             whitelisted_domains: whitelisted_domains,
             blacklisted_domains: blacklisted_domains,
+            dns: dns,
             not_rfc_mx_lookup_flow: executor_configuration.not_rfc_mx_lookup_flow,
+            smtp_fail_fast: executor_configuration.smtp_fail_fast,
             smtp_safe_check: executor_configuration.smtp_safe_check,
             email_pattern: email_pattern,
             smtp_error_body_pattern: smtp_error_body_pattern

data/lib/truemail/log/serializer/validator_base.rb

@@ -13,6 +13,10 @@ module Truemail
 
         attr_reader :validation_type
 
+        def replace_invalid_chars
+          ->(value) { value.encode('UTF-8', invalid: :replace) }
+        end
+
         def smtp_debug
           validation_smtp_debug = executor_result.smtp_debug
           return unless validation_smtp_debug
@@ -22,7 +26,7 @@ module Truemail
               mail_host: smtp_request.host,
               port_opened: smtp_response.port_opened,
               connection: smtp_response.connection,
-              errors: smtp_response.errors
+              errors: smtp_response.errors.transform_values(&replace_invalid_chars)
             }
           end
         end
@@ -30,7 +34,7 @@ module Truemail
         def result
           @result ||=
             {
-              date: Time.now,
+              date: ::Time.now,
               email: executor_result.email,
               validation_type: validation_type,
               success: executor_result.success,

data/lib/truemail/log/serializer/validator_text.rb

@@ -20,8 +20,8 @@ module Truemail
           enumerable_object.inject([]) do |formatted_data, (key, value)|
             data =
               case
-              when value.is_a?(Hash) then "\n#{printer(value)}"
-              when value.is_a?(Array) then value.join(', ')
+              when value.is_a?(::Hash) then "\n#{printer(value)}"
+              when value.is_a?(::Array) then value.join(', ')
               else value
               end
             formatted_data << "#{key.to_s.tr('_', ' ')}: #{data}".chomp << "\n"

data/lib/truemail/logger.rb

@@ -23,7 +23,7 @@ module Truemail
     def init_log_file
       output_file = Pathname(file)
       return output_file if output_file.exist?
-      output_file.parent.mkpath && FileUtils.touch(output_file)
+      output_file.parent.mkpath && ::FileUtils.touch(output_file)
       output_file
     end
 

data/lib/truemail/validate/mx.rb

@@ -3,8 +3,6 @@
 module Truemail
   module Validate
     class Mx < Truemail::Validate::Base
-      require 'resolv'
-
       ERROR = 'target host(s) not found'
       NULL_MX_RECORD = 'null_mx_record'
 
@@ -43,11 +41,11 @@ module Truemail
       end
 
       def mx_records(hostname)
-        domain_mx_records = Resolv::DNS.new.getresources(hostname, Resolv::DNS::Resource::IN::MX)
+        domain_mx_records = Truemail::Dns::Resolver.mx_records(hostname, configuration: configuration)
         return [Truemail::Validate::Mx::NULL_MX_RECORD] if null_mx?(domain_mx_records)
-        domain_mx_records.sort_by(&:preference).map do |mx_record|
-          Resolv.getaddresses(mx_record.exchange.to_s)
-        end.flatten
+        domain_mx_records.sort_by(&:preference).flat_map do |mx_record|
+          Truemail::Dns::Resolver.a_records(mx_record.exchange.to_s, configuration: configuration)
+        end
       end
 
       def mail_servers_found?
@@ -64,15 +62,15 @@ module Truemail
       end
 
       def a_record(hostname)
-        Resolv.getaddress(hostname)
+        Truemail::Dns::Resolver.a_record(hostname, configuration: configuration)
       end
 
       def hosts_from_cname_records?
-        cname_records = Resolv::DNS.new.getresources(domain, Resolv::DNS::Resource::IN::CNAME)
+        cname_records = Truemail::Dns::Resolver.cname_records(domain, configuration: configuration)
         return if cname_records.empty?
         cname_records.each do |cname_record|
           host = a_record(cname_record.name.to_s)
-          hostname = Resolv.getname(host)
+          hostname = Truemail::Dns::Resolver.dns_lookup(host, configuration: configuration)
           found_hosts = mx_records(hostname)
           fetch_target_hosts(found_hosts.empty? ? [host] : found_hosts)
         end