mock_dns_server 0.3.0

data/lib/mock_dns_server/server_context.rb

@@ -0,0 +1,57 @@
+require 'dnsruby'
+require 'forwardable'
+
+require 'mock_dns_server/conditional_actions'
+require 'mock_dns_server/history'
+require 'mock_dns_server/message_builder'
+
+module MockDnsServer
+
+class ServerContext
+
+  include MessageBuilder
+  extend Forwardable
+
+  def_delegators :@conditional_actions, :respond_to
+
+  attr_reader :server, :port, :host, :timeout_secs, :mutex,
+              :conditional_actions, :history, :verbose
+
+  #def shutdown_requested?; @shutdown_requested          end
+  #def request_shutdown;    @shutdown_requested = true   end
+
+
+  def initialize(server, options = {})
+    @server = server
+    @port = options[:port]
+    @host = options[:host]
+    @timeout_secs = options[:timeout_secs]
+    @verbose = options[:verbose]
+    @mutex = Mutex.new
+    @conditional_actions = ConditionalActions.new(self)
+    @history = History.new(self)
+  end
+
+
+  def with_mutex(&block)
+
+    start_time = Time.now
+    duration = ->() do
+      now = Time.now
+      elapsed_in_usec = (now - start_time) * 1_000_000
+      start_time = now
+      "#{elapsed_in_usec} usec"
+    end
+
+    #puts "#{Thread.current}: Waiting for mutex..."
+    mutex.synchronize do
+      #puts "time to get mutex: #{duration.()}"
+      block.call
+      #puts "time using mutex: #{duration.()}"
+    end
+  end
+
+
+end
+
+end

data/lib/mock_dns_server/server_thread.rb

@@ -0,0 +1,13 @@
+module MockDnsServer
+
+class ServerThread < Thread
+
+  attr_accessor :server
+
+  # Thread::abort_on_exception = true
+
+  def self.all
+    Thread.list.select { |thread| thread.is_a?(ServerThread) }
+  end
+end
+end

data/lib/mock_dns_server/version.rb

@@ -0,0 +1,3 @@
+module MockDnsServer
+  VERSION = "0.3.0"
+end

data/mock_dns_server.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mock_dns_server/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mock_dns_server"
+  spec.version       = MockDnsServer::VERSION
+  spec.authors       = ["Keith Bennett"]
+  spec.email         = ["keithrbennett@gmail.com"]
+  spec.description   = %q{Mock DNS Server}
+  spec.summary       = %q{Mock DNS Server}
+  spec.homepage      = "http://www.github.com" # TODO: change when able
+  spec.license       = "BSD-3-Clause"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "dnsruby", '~> 1.54'
+  spec.add_dependency "hexdump", '~> 0.2'
+  spec.add_dependency "thread_safe", '~> 0.3'
+
+  spec.add_dependency "awesome_print", '~> 1.2'
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rake", '~> 10.1'
+  spec.add_development_dependency "rspec", '~> 3.0'
+
+end

data/spec/mock_dns_server/conditions_factory_spec.rb

@@ -0,0 +1,58 @@
+require 'dnsruby'
+require 'spec_helper'
+require 'mock_dns_server/predicate_factory'
+
+module MockDnsServer
+
+describe PredicateFactory do
+
+  describe "Conditions.message_qtype" do
+
+    subject { PredicateFactory.new.qtype('SOA') }
+
+    it "correctly returns true" do
+      message = Dnsruby::Message.new('com', Dnsruby::Types.SOA)
+      expect(subject.call(message)).to be true
+    end
+
+    it "correctly returns false" do
+      message = Dnsruby::Message.new('ruby-lang.org', Dnsruby::Types.A)
+      expect(subject.call(message)).to be false
+    end
+
+  end
+
+
+  describe "Conditions.message_qname" do
+
+    subject { PredicateFactory.new.qname('ruby-lang.org') }
+
+    it "correctly returns true" do
+      message = Dnsruby::Message.new('ruby-lang.org', 'A')
+      expect(subject.call(message)).to be true
+    end
+
+    it "correctly returns false" do
+      message = Dnsruby::Message.new('python.org', 'A')
+      expect(subject.call(message)).to be false
+    end
+  end
+
+  describe "Conditions.message_qclass" do
+
+    subject { PredicateFactory.new.qclass('IN')}
+
+    it "correctly returns true" do
+      message = Dnsruby::Message.new('ruby-lang.org', 'A', 'IN')
+      expect(subject.call(message)).to be true
+    end
+
+    it "correctly returns false" do
+      message = Dnsruby::Message.new('ruby-lang.org', 'A', 'CH')
+      expect(subject.call(message)).to be false
+    end
+
+  end
+
+end
+end

data/spec/mock_dns_server/history_inspections_spec.rb

@@ -0,0 +1,84 @@
+require_relative '../spec_helper'
+
+require 'dnsruby'
+require 'mock_dns_server/history_inspections'
+require 'mock_dns_server/message_builder'
+
+module MockDnsServer
+
+describe HistoryInspections do
+
+  include MessageBuilder
+
+  let (:hi) { HistoryInspections.new }
+
+  let (:test_data) do
+    soa_opts = { name: 'com', mname: 'a.gtld-servers.net.', serial: 1001 }
+
+    [
+        { type: :outgoing, message: Dnsruby::Message.new('ruby-lang.org'), protocol: :udp, id: 1 },
+        { type: :outgoing, message: Dnsruby::Message.new('ruby-lang.org'), protocol: :tcp, id: 2 },
+
+        { type: :incoming, message: soa_response(soa_opts), protocol: :udp, id: 3 },
+        { type: :incoming, message: soa_response(soa_opts), protocol: :tcp, id: 4 },
+
+        { type: :incoming, message: specified_a_response("foo.example.com. 86400 A 10.1.2.3"), protocol: :udp, id: 5 },
+        { type: :incoming, message: specified_a_response("foo.example.com. 86400 A 10.1.2.3"), protocol: :tcp, id: 6 },
+    ]
+  end
+
+  def ids(records)
+    records.map { |rec| rec[:id] }
+  end
+
+  it 'correctly tests for incoming' do
+    inspection = hi.type(:incoming)
+    result = hi.apply(test_data, inspection)
+    expect(ids(result)).to eq([3, 4, 5, 6])
+  end
+
+  it 'correctly tests for outgoing' do
+    inspection = hi.type(:outgoing)
+    result = hi.apply(test_data, inspection)
+    expect(ids(result)).to eq([1, 2])
+  end
+
+  it 'correctly tests for udp' do
+    inspection = hi.protocol(:udp)
+    result = hi.apply(test_data, inspection)
+    expect(ids(result)).to eq([1, 3, 5])
+  end
+
+  it 'correctly tests for tcp' do
+    inspection = hi.protocol(:tcp)
+    result = hi.apply(test_data, inspection)
+    expect(ids(result)).to eq([2, 4, 6])
+  end
+
+  it 'correctly tests for qtype' do
+    inspection = hi.qtype('SOA')
+    result = hi.apply(test_data, inspection)
+    expect(ids(result)).to eq([3, 4])
+  end
+
+  it 'correctly operates with the all predicate' do
+    inspection = hi.all(hi.qtype('SOA'), hi.protocol(:udp))
+    result = hi.apply(test_data, inspection)
+    expect(ids(result)).to eq([3])
+  end
+
+  it 'correctly operates with the any predicate' do
+    inspection = hi.any(hi.qtype('SOA'), hi.protocol(:udp))
+    result = hi.apply(test_data, inspection)
+    expect(ids(result)).to eq([1, 3, 4, 5])
+  end
+
+  it 'correctly operates with the none predicate' do
+    inspection = hi.none(hi.qtype('SOA'), hi.protocol(:udp))
+    result = hi.apply(test_data, inspection)
+    expect(ids(result)).to eq([2, 6])
+  end
+
+
+end
+end

data/spec/mock_dns_server/history_spec.rb

@@ -0,0 +1,65 @@
+require_relative '../spec_helper'
+
+require 'mock_dns_server/history'
+require 'mock_dns_server/server'
+require 'mock_dns_server/conditional_action_factory'
+
+
+module MockDnsServer
+
+
+  describe History do
+
+    subject { History.new(nil) }
+    let(:options) { { port: 9999 } }
+    let(:sample_message) { 'Hello from RSpec' }
+    let(:caf)  { ConditionalActionFactory.new }
+
+    it 'should report the correct size' do
+      n = 3
+      n.times { |n| subject.add_incoming(nil, nil, nil) }
+      expect(subject.size).to eq(n)
+    end
+
+
+    it 'should retain its content even after its copy is cleared' do
+      n = 3
+      n.times { |n| subject.add_incoming(nil, nil, nil) }
+      copy = subject.copy
+      copy.clear
+      expect(subject.size).to eq(n)
+    end
+
+
+    it 'should create a new copy for each clone' do
+      n = 3
+      n.times { |n| subject.add_incoming(nil, nil, nil) }
+      clone1 = subject.copy
+      clone2 = subject.copy
+      expect(clone1).not_to equal(clone2)
+    end
+
+
+    it 'should clone each record in the array' do
+      subject.add_incoming(nil, nil, nil)
+      clone1 = subject.copy
+      clone2 = subject.copy
+      expect(clone1.first).not_to equal(clone2.first)
+    end
+
+
+    it 'should contain entries from traffic' do
+
+      Server.with_new_server(options) do |server|
+        server.add_conditional_action(caf.echo)
+        server.start
+
+        socket = UDPSocket.new
+        socket.send(sample_message, 0, '127.0.0.1', options[:port])
+        _, _ = socket.recvfrom(10_000)
+        history = server.history_copy
+        expect(history.size > 0 && history.first[:type] == :incoming).to be true
+      end
+    end
+  end
+end

data/spec/mock_dns_server/ip_address_dispenser_spec.rb

@@ -0,0 +1,30 @@
+require_relative '../spec_helper'
+
+require 'mock_dns_server/ip_address_dispenser'
+
+module MockDnsServer
+
+describe IpAddressDispenser do
+
+  it "should return the initial value when next is called for the first time" do
+    expect(IpAddressDispenser.new('10.10.10.10').next.to_s).to eq('10.10.10.10')
+  end
+
+  it "should increment correctly in the least significant octet" do
+    expect(IpAddressDispenser.new('10.10.10.10').next(2).to_s).to eq('10.10.10.11')
+  end
+
+  it "should roll over correctly in the 2 least significant octets" do
+    expect(IpAddressDispenser.new('10.10.10.255').next(2).to_s).to eq('10.10.11.0')
+  end
+
+  it "should does not raise an error and produces a valid IP address when called on 255.255.255.255" do
+    f = ->() do
+      new_address = IpAddressDispenser.new('255.255.255.255').next
+      IPAddr.new(new_address)
+    end
+    expect(f).not_to raise_error
+  end
+
+end
+end

data/spec/mock_dns_server/message_builder_spec.rb

@@ -0,0 +1,18 @@
+require_relative '../spec_helper'
+
+require 'mock_dns_server/message_builder'
+
+module MockDnsServer
+
+describe MessageBuilder do
+
+  include MessageBuilder
+
+  it 'creates dummy A records correctly' do
+    num_records = 3
+    response = dummy_a_response(num_records, 'ruby-lang.org')
+    expect(response.answer.size).to eq(num_records)
+  end
+
+end
+end

data/spec/mock_dns_server/predicate_factory_spec.rb

@@ -0,0 +1,147 @@
+require_relative '../spec_helper'
+
+require 'dnsruby'
+require 'mock_dns_server/predicate_factory'
+
+module MockDnsServer
+
+  describe PredicateFactory do
+
+    subject { PredicateFactory.new }
+
+    it '.always_true works' do
+      func = subject.always_true
+      expect(func.call(nil, nil)).to be true
+    end
+
+
+    it '.always_false works' do
+      func = subject.always_false
+      expect(func.call(nil, nil)).to be false
+    end
+
+    
+    it '.and works' do
+      t = subject.always_true
+      f = subject.always_false
+
+      composite_func = subject.all(t, t)
+      expect(composite_func.call(nil, nil)).to be true
+
+      composite_func = subject.all(t, f)
+      expect(composite_func.call(nil, nil)).to be false
+    end
+
+    it '.not works' do
+      t = subject.always_true
+      f = subject.always_false
+
+      composite_func = subject.none(f, f)
+      expect(composite_func.call(nil, nil)).to be true
+
+      composite_func = subject.none(t, f)
+      expect(composite_func.call(nil, nil)).to be false
+    end
+
+    it '.or works' do
+      t = subject.always_true
+      f = subject.always_false
+
+      composite_func = subject.any(t, f)
+      expect(composite_func.call(nil, nil)).to be true
+
+      composite_func = subject.any(f, f)
+      expect(composite_func.call(nil, nil)).to be false
+    end
+
+    it 'qname works' do
+      message = Dnsruby::Message.new('amazon.com', 'A')
+
+      predicate = subject.qname('amazon.com')
+      expect(predicate.(message)).to be true
+
+      predicate = subject.qname('ruby-lang.org')
+      expect(predicate.(message)).to be false
+    end
+
+    it 'qtype works' do
+      message = Dnsruby::Message.new('amazon.com', 'A')
+
+      predicate = subject.qtype('A')
+      expect(predicate.(message)).to be true
+
+      predicate = subject.qtype('SOA')
+      expect(predicate.(message)).to be false
+
+    end
+
+    it 'qclass works' do
+      message = Dnsruby::Message.new('amazon.com', 'A', 'CH')
+
+      predicate = subject.qclass('CH')
+      expect(predicate.(message)).to be true
+
+      predicate = subject.qclass('ZZ')
+      expect(predicate.(message)).to be false
+    end
+
+    it 'soa works' do
+      message = Dnsruby::Message.new('com', 'SOA')
+      expect(subject.soa.(message)).to be true
+
+      message = Dnsruby::Message.new('x.com', 'A')
+      expect(subject.soa.(message)).to be false
+    end
+
+    it 'axfr works' do
+      message = Dnsruby::Message.new('com', 'AXFR')
+      expect(subject.axfr.(message)).to be true
+
+      message = Dnsruby::Message.new('x.com', 'A')
+      expect(subject.axfr.(message)).to be false
+    end
+
+    it 'ixfr works' do
+      message = Dnsruby::Message.new('com', 'IXFR')
+      expect(subject.ixfr.(message)).to be true
+
+      message = Dnsruby::Message.new('x.com', 'A')
+      expect(subject.ixfr.(message)).to be false
+    end
+
+
+    it 'qtype_and_qname works' do
+      message = Dnsruby::Message.new('com', 'SOA')
+      predicate = subject.qtype_and_qname('SOA', 'com')
+      expect(predicate.(message)).to be true
+    end
+
+    it 'a_request works' do
+      message = Dnsruby::Message.new('amazon.com', 'A')
+
+      predicate = subject.a_request('amazon.com')
+      expect(predicate.(message)).to be true
+
+      predicate = subject.a_request('ruby-lang.org')
+      expect(predicate.(message)).to be false
+
+      predicate = subject.qname('ruby-lang.org')
+      expect(predicate.(message)).to be false
+
+      message = Dnsruby::Message.new('amazon.com', 'SOA')
+      predicate = subject.a_request('amazon.com')
+      expect(predicate.(message)).to be false
+    end
+
+
+    it 'is case insensitive' do
+      message = Dnsruby::Message.new('AmAzOn.CoM', 'a')
+
+      expect(subject.qtype('A').(message)).to be true
+      expect(subject.qname('amazon.com').(message)).to be true
+    end
+  end
+
+
+
+end