dns_mock 0.1.0

data/lib/dns_mock.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'dns_mock/core'
+
+module DnsMock
+  class << self
+    def start_server(server = DnsMock::Server, records: {}, port: nil)
+      server.new(records: records, port: port)
+    end
+
+    def running_servers
+      ::ObjectSpace.each_object(DnsMock::Server).select(&:alive?)
+    end
+
+    def stop_running_servers!
+      running_servers.all?(&:stop!)
+    end
+  end
+end

data/lib/dns_mock/core.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'resolv'
+require 'socket'
+
+module DnsMock
+  AVAILABLE_DNS_RECORD_TYPES = %i[a aaaa cname mx ns soa txt].freeze
+
+  module Error
+    require_relative '../dns_mock/error/argument_type'
+    require_relative '../dns_mock/error/port_in_use'
+    require_relative '../dns_mock/error/random_free_port'
+    require_relative '../dns_mock/error/record_context_type'
+    require_relative '../dns_mock/error/record_context'
+    require_relative '../dns_mock/error/record_host_type'
+    require_relative '../dns_mock/error/record_not_found'
+    require_relative '../dns_mock/error/record_type'
+    require_relative '../dns_mock/error/helper'
+  end
+
+  module Record
+    module Factory
+      require_relative '../dns_mock/record/factory/base'
+      require_relative '../dns_mock/record/factory/a'
+      require_relative '../dns_mock/record/factory/aaaa'
+      require_relative '../dns_mock/record/factory/cname'
+      require_relative '../dns_mock/record/factory/mx'
+      require_relative '../dns_mock/record/factory/ns'
+      require_relative '../dns_mock/record/factory/soa'
+      require_relative '../dns_mock/record/factory/txt'
+    end
+  end
+
+  module Record
+    module Builder
+      require_relative '../dns_mock/record/builder/base'
+      require_relative '../dns_mock/record/builder/a'
+      require_relative '../dns_mock/record/builder/aaaa'
+      require_relative '../dns_mock/record/builder/cname'
+      require_relative '../dns_mock/record/builder/mx'
+      require_relative '../dns_mock/record/builder/ns'
+      require_relative '../dns_mock/record/builder/soa'
+      require_relative '../dns_mock/record/builder/txt'
+    end
+  end
+
+  module Response
+    require_relative '../dns_mock/response/answer'
+    require_relative '../dns_mock/response/message'
+  end
+
+  require_relative '../dns_mock/version'
+  require_relative '../dns_mock/server/records_dictionary_builder'
+  require_relative '../dns_mock/server/random_available_port'
+  require_relative '../dns_mock/server'
+end

data/lib/dns_mock/error/argument_type.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DnsMock
+  module Error
+    ArgumentType = ::Class.new(::ArgumentError) do
+      def initialize(argument_class)
+        super("Argument class is a #{argument_class}. Should be a Hash")
+      end
+    end
+  end
+end

data/lib/dns_mock/error/helper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DnsMock
+  module Error
+    module Helper
+      def raise_record_context_type_error(record_type, record_context, expected_type)
+        current_type, record_type = record_context.class, record_type.upcase
+        raise_unless(DnsMock::Error::RecordContextType.new(current_type, record_type, expected_type), current_type.eql?(expected_type))
+      end
+
+      def raise_record_type_error(record_type, condition)
+        raise_unless(DnsMock::Error::RecordType.new(record_type), condition)
+      end
+
+      private
+
+      def raise_unless(error_instance, condition)
+        raise error_instance unless condition
+      end
+    end
+  end
+end

data/lib/dns_mock/error/port_in_use.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DnsMock
+  module Error
+    PortInUse = ::Class.new(::RuntimeError) do
+      def initialize(hostname, port)
+        super("Impossible to bind UDP DNS mock server on #{hostname}:#{port}. Address already in use")
+      end
+    end
+  end
+end

data/lib/dns_mock/error/random_free_port.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DnsMock
+  module Error
+    RandomFreePort = ::Class.new(::RuntimeError) do
+      def initialize(attempts)
+        super("Impossible to find free random port in #{attempts} attempts")
+      end
+    end
+  end
+end

data/lib/dns_mock/error/record_context.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DnsMock
+  module Error
+    RecordContext = ::Class.new(::StandardError) do
+      def initialize(record_context, record_type)
+        super("#{record_context}. Invalid #{record_type} record context")
+      end
+    end
+  end
+end

data/lib/dns_mock/error/record_context_type.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DnsMock
+  module Error
+    RecordContextType = ::Class.new(::ArgumentError) do
+      def initialize(record_context_type, record_type, expected_record_context_type)
+        super(
+          "#{record_context_type} is invalid record context type for " \
+          "#{record_type} record. Should be a " \
+          "#{expected_record_context_type}"
+        )
+      end
+    end
+  end
+end

data/lib/dns_mock/error/record_host_type.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DnsMock
+  module Error
+    RecordHostType = ::Class.new(::ArgumentError) do
+      def initialize(hostname, hostname_class)
+        super("Hostname #{hostname} type is #{hostname_class}. Should be a String")
+      end
+    end
+  end
+end

data/lib/dns_mock/error/record_not_found.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DnsMock
+  module Error
+    RecordNotFound = ::Class.new(::StandardError) do
+      def initialize(record_type, hostname)
+        super("#{record_type.upcase} record not found for #{hostname} in predefined records dictionary")
+      end
+    end
+  end
+end

data/lib/dns_mock/error/record_type.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DnsMock
+  module Error
+    RecordType = ::Class.new(::StandardError) do
+      def initialize(record_type)
+        super("#{record_type} is invalid record type")
+      end
+    end
+  end
+end

data/lib/dns_mock/record/builder/a.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DnsMock
+  module Record
+    module Builder
+      A = ::Class.new(DnsMock::Record::Builder::Base)
+    end
+  end
+end

data/lib/dns_mock/record/builder/aaaa.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DnsMock
+  module Record
+    module Builder
+      Aaaa = ::Class.new(DnsMock::Record::Builder::Base)
+    end
+  end
+end

data/lib/dns_mock/record/builder/base.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module DnsMock
+  module Record
+    module Builder
+      class Base
+        def self.call(target_factory, records_data)
+          new(target_factory, records_data).build
+        end
+
+        def initialize(target_factory, records_data)
+          @target_factory = target_factory
+          @records_data = records_data
+        end
+
+        def build
+          records_data.map { |record_data| target_factory.new(record_data: record_data).create }
+        end
+
+        private
+
+        attr_reader :target_factory, :records_data
+      end
+    end
+  end
+end

data/lib/dns_mock/record/builder/cname.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module DnsMock
+  module Record
+    module Builder
+      Cname = ::Class.new(DnsMock::Record::Builder::Base) do
+        def build
+          [target_factory.new(record_data: records_data).create]
+        end
+      end
+    end
+  end
+end

data/lib/dns_mock/record/builder/mx.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DnsMock
+  module Record
+    module Builder
+      class Mx < DnsMock::Record::Builder::Base
+        RECORD_PREFERENCE_STEP = 10
+
+        def build
+          records_data.map.with_index(1) do |record_data, record_preference|
+            target_factory.new(
+              record_data: [
+                record_preference * DnsMock::Record::Builder::Mx::RECORD_PREFERENCE_STEP,
+                record_data
+              ]
+            ).create
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dns_mock/record/builder/ns.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DnsMock
+  module Record
+    module Builder
+      Ns = ::Class.new(DnsMock::Record::Builder::Base)
+    end
+  end
+end

data/lib/dns_mock/record/builder/soa.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DnsMock
+  module Record
+    module Builder
+      class Soa < DnsMock::Record::Builder::Base
+        FACTORY_ARGS_ORDER = %i[mname rname serial refresh retry expire minimum].freeze
+
+        def build
+          records_data.map do |record_data|
+            target_factory.new(
+              record_data: record_data.values_at(*DnsMock::Record::Builder::Soa::FACTORY_ARGS_ORDER)
+            ).create
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dns_mock/record/builder/txt.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DnsMock
+  module Record
+    module Builder
+      Txt = ::Class.new(DnsMock::Record::Builder::Base)
+    end
+  end
+end

data/lib/dns_mock/record/factory/a.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DnsMock
+  module Record
+    module Factory
+      A = ::Class.new(DnsMock::Record::Factory::Base) do
+        record_type :a
+
+        def instance_params
+          record_data
+        end
+      end
+    end
+  end
+end

data/lib/dns_mock/record/factory/aaaa.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DnsMock
+  module Record
+    module Factory
+      Aaaa = ::Class.new(DnsMock::Record::Factory::Base) do
+        record_type :aaaa
+
+        def instance_params
+          record_data
+        end
+      end
+    end
+  end
+end

data/lib/dns_mock/record/factory/base.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module DnsMock
+  module Record
+    module Factory
+      class Base
+        extend DnsMock::Error::Helper
+
+        class << self
+          attr_reader :target_class
+
+          def record_type(record_type)
+            @target_class = ::Resolv::DNS::Resource::IN.const_get(
+              record_type_check(record_type).upcase
+            )
+          end
+
+          private
+
+          def record_type_check(defined_record_type)
+            raise_record_type_error(defined_record_type, DnsMock::AVAILABLE_DNS_RECORD_TYPES.include?(defined_record_type))
+            defined_record_type
+          end
+        end
+
+        def initialize(dns_name = ::Resolv::DNS::Name, record_data:)
+          @dns_name = dns_name
+          @record_data = record_data
+        end
+
+        def instance_params; end
+
+        def create
+          self.class.target_class.public_send(:new, *instance_params)
+        rescue => error
+          raise DnsMock::Error::RecordContext.new(error.message, record_type)
+        end
+
+        private
+
+        attr_reader :dns_name, :record_data
+
+        def record_type
+          self.class.name.split('::').last.upcase
+        end
+
+        def create_dns_name(hostname)
+          raise ::ArgumentError, "cannot interpret as DNS name: #{hostname}" unless hostname.is_a?(::String)
+          dns_name.create("#{hostname}.")
+        end
+      end
+    end
+  end
+end

data/lib/dns_mock/record/factory/cname.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DnsMock
+  module Record
+    module Factory
+      Cname = ::Class.new(DnsMock::Record::Factory::Base) do
+        record_type :cname
+
+        def instance_params
+          [create_dns_name(record_data)]
+        end
+      end
+    end
+  end
+end

data/lib/dns_mock/record/factory/mx.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DnsMock
+  module Record
+    module Factory
+      Mx = ::Class.new(DnsMock::Record::Factory::Base) do
+        record_type :mx
+
+        def instance_params
+          [record_data.first, create_dns_name(record_data.last)]
+        end
+      end
+    end
+  end
+end