rubydns 0.6.0 → 2.0.0

data/lib/rubydns/rule_based_server.rb

@@ -0,0 +1,180 @@
+# Copyright, 2009, 2012, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'async/dns/server'
+
+module RubyDNS
+	# Provides the core of the RubyDNS domain-specific language (DSL). It contains a list of rules which are used to match against incoming DNS questions. These rules are used to generate responses which are either DNS resource records or failures.
+	class RuleBasedServer < Async::DNS::Server
+		# Represents a single rule in the server.
+		class Rule
+			def initialize(pattern, callback)
+				@pattern = pattern
+				@callback = callback
+			end
+			
+			# Returns true if the name and resource_class are sufficient:
+			def match(name, resource_class)
+				# If the pattern doesn't specify any resource classes, we implicitly pass this test:
+				return true if @pattern.size < 2
+				
+				# Otherwise, we try to match against some specific resource classes:
+				if Class === @pattern[1]
+					@pattern[1] == resource_class
+				else
+					@pattern[1].include?(resource_class) rescue false
+				end
+			end
+			
+			# Invoke the rule, if it matches the incoming request, it is evaluated and returns `true`, otherwise returns `false`.
+			def call(server, name, resource_class, transaction)
+				unless match(name, resource_class)
+					server.logger.debug "<#{transaction.query.id}> Resource class #{resource_class} failed to match #{@pattern[1].inspect}!"
+					
+					return false
+				end
+				
+				# Does this rule match against the supplied name?
+				case @pattern[0]
+				when Regexp
+					match_data = @pattern[0].match(name)
+					
+					if match_data
+						server.logger.debug "<#{transaction.query.id}> Regexp pattern matched with #{match_data.inspect}."
+						
+						@callback[transaction, match_data]
+						
+						return true
+					end
+				when String
+					if @pattern[0] == name
+						server.logger.debug "<#{transaction.query.id}> String pattern matched."
+						
+						@callback[transaction]
+						
+						return true
+					end
+				else
+					if (@pattern[0].call(name, resource_class) rescue false)
+						server.logger.debug "<#{transaction.query.id}> Callable pattern matched."
+						
+						@callback[transaction]
+						
+						return true
+					end
+				end
+				
+				server.logger.debug "<#{transaction.query.id}> No pattern matched."
+				
+				# We failed to match the pattern.
+				return false
+			end
+			
+			def to_s
+				@pattern.inspect
+			end
+		end
+		
+		# Instantiate a server with a block
+		#
+		#	server = Server.new do
+		#		match(/server.mydomain.com/, IN::A) do |transaction|
+		#			transaction.respond!("1.2.3.4")
+		#		end
+		#	end
+		#
+		def initialize(*args, &block)
+			super(*args)
+			
+			@events = {}
+			@rules = []
+			@otherwise = nil
+			
+			if block_given?
+				instance_eval(&block)
+			end
+		end
+
+		attr_accessor :logger
+
+		# This function connects a pattern with a block. A pattern is either a String or a Regex instance. Optionally, a second argument can be provided which is either a String, Symbol or Array of resource record types which the rule matches against.
+		# 
+		#	match("www.google.com")
+		#	match("gmail.com", IN::MX)
+		#	match(/g?mail.(com|org|net)/, [IN::MX, IN::A])
+		#
+		def match(*pattern, &block)
+			@rules << Rule.new(pattern, block)
+		end
+
+		# Register a named event which may be invoked later using #fire
+		#
+		#	on(:start) do |server|
+		#		Process::Daemon::Permissions.change_user(RUN_AS)
+		#	end
+		def on(event_name, &block)
+			@events[event_name] = block
+		end
+		
+		# Fire the named event, which must have been registered using on.
+		def fire(event_name)
+			callback = @events[event_name]
+			
+			if callback
+				callback.call(self)
+			end
+		end
+		
+		# Specify a default block to execute if all other rules fail to match. This block is typially used to pass the request on to another server (i.e. recursive request).
+		#
+		#	otherwise do |transaction|
+		#		transaction.passthrough!($R)
+		#	end
+		#
+		def otherwise(&block)
+			@otherwise = block
+		end
+		
+		# If you match a rule, but decide within the rule that it isn't the correct one to use, you can call `next!` to evaluate the next rule - in other words, to continue falling down through the list of rules.
+		def next!
+			throw :next
+		end
+		
+		# Give a name and a record type, try to match a rule and use it for processing the given arguments.
+		def process(name, resource_class, transaction)
+			@logger.debug {"<#{transaction.query.id}> Searching for #{name} #{resource_class.name}"}
+			
+			@rules.each do |rule|
+				@logger.debug {"<#{transaction.query.id}> Checking rule #{rule}..."}
+				
+				catch (:next) do
+					# If the rule returns true, we assume that it was successful and no further rules need to be evaluated.
+					return if rule.call(self, name, resource_class, transaction)
+				end
+			end
+			
+			if @otherwise
+				@otherwise.call(transaction)
+			else
+				@logger.warn "<#{transaction.query.id}> Failed to handle #{name} #{resource_class.name}!"
+			end
+		end
+	end
+end

data/lib/rubydns/version.rb

@@ -19,5 +19,5 @@
 # THE SOFTWARE.
 
 module RubyDNS
-	VERSION = "0.6.0"
+	VERSION = '2.0.0'
 end

data/lib/rubydns.rb

@@ -18,74 +18,24 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'rubydns/version'
+require 'async/dns'
 
-if RUBY_VERSION < "1.9"
-	require 'rubydns/extensions/string-1.8'
-elsif RUBY_VERSION < "1.9.3"
-	require 'rubydns/extensions/string-1.9.2'
-else
-	require 'rubydns/extensions/string-1.9.3'
-end
-
-require 'rubydns/message'
-require 'rubydns/server'
-require 'rubydns/resolver'
-require 'rubydns/handler'
-
-require 'logger'
-
-require 'rexec'
-require 'rexec/daemon'
-
-require 'rubydns/handler'
+require_relative 'rubydns/version'
+require_relative 'rubydns/rule_based_server'
 
 module RubyDNS
+	# Backwards compatibility:
+	Resolver = Async::DNS::Resolver
 	
-	# Run a server with the given rules. A number of options can be supplied:
-	#
-	# <tt>:interfaces</tt>:: A set of sockets or addresses as defined below.
-	#
-	# One important feature of DNS is the port it runs on. The <tt>options[:listen]</tt>
-	# allows you to specify a set of network interfaces and ports to run the server on. This
-	# must be a list of <tt>[protocol, interface address, port]</tt>.
-	# 
-	#   INTERFACES = [[:udp, "0.0.0.0", 5300]]
-	#   RubyDNS::run_server(:listen => INTERFACES) do
-	#     ...
-	#   end
-	#
-	# You can specify already connected sockets if need be:
-	#
-	#   socket = UDPSocket.new; socket.bind("0.0.0.0", 53)
-	#   Process::Sys.setuid(server_uid)
-	#   INTERFACES = [socket]
-	#
-	# The default interface is <tt>[[:udp, "0.0.0.0", 53]]</tt>. The server typically needs
-	# to run as root for this to work, since port 53 is privileged.
-	#
-	def self.run_server (options = {}, &block)
-		server = RubyDNS::Server.new(&block)
-		server.logger.info "Starting RubyDNS server (v#{RubyDNS::VERSION})..."
-		
-		options[:listen] ||= [[:udp, "0.0.0.0", 53], [:tcp, "0.0.0.0", 53]]
-		
-		EventMachine.run do
-			server.fire(:setup)
-			
-			# Setup server sockets
-			options[:listen].each do |spec|
-				server.logger.info "Listening on #{spec.join(':')}"
-				if spec[0] == :udp
-					EventMachine.open_datagram_socket(spec[1], spec[2], UDPHandler, server)
-				elsif spec[0] == :tcp
-					EventMachine.start_server(spec[1], spec[2], TCPHandler, server)
-				end
-			end
-			
-			server.fire(:start)
+	# Run a server with the given rules.
+	def self.run_server (*args, server_class: RuleBasedServer, **options, &block)
+		if listen = options.delete(:listen)
+			warn "Using `listen:` option is deprecated, please pass as the first argument."
+			args.unshift(listen)
 		end
 		
-		server.fire(:stop)
+		server = server_class.new(*args, **options, &block)
+		
+		server.run
 	end
 end

data/rubydns.gemspec

@@ -3,31 +3,37 @@ lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'rubydns/version'
 
-Gem::Specification.new do |gem|
-	gem.name          = "rubydns"
-	gem.version       = RubyDNS::VERSION
-	gem.authors       = ["Samuel Williams"]
-	gem.email         = ["samuel.williams@oriontransfer.co.nz"]
-	gem.description   = <<-EOF
-	RubyDNS is a high-performance DNS server which can be easily integrated into
-	other projects or used as a stand-alone daemon (via RExec). By default it uses
-	rule-based pattern matching. Results can be hard-coded, computed, fetched from
-	a remote DNS server or fetched from a local cache, depending on requirements.
+Gem::Specification.new do |spec|
+	spec.name          = "rubydns"
+	spec.version       = RubyDNS::VERSION
+	spec.authors       = ["Samuel Williams"]
+	spec.email         = ["samuel.williams@oriontransfer.co.nz"]
+	spec.description   = <<-EOF
+		RubyDNS is a high-performance DNS server which can be easily integrated into
+		other projects or used as a stand-alone daemon. By default it uses
+		rule-based pattern matching. Results can be hard-coded, computed, fetched from
+		a remote DNS server or fetched from a local cache, depending on requirements.
 
-	In addition, RubyDNS includes a high-performance asynchronous DNS resolver
-	built on top of EventMachine. This module can be used by itself in client
-	applications without using the full RubyDNS server stack.
+		In addition, RubyDNS includes a high-performance asynchronous DNS resolver
+		built on top of Celluloid. This module can be used by itself in client
+		applications without using the full RubyDNS server stack.
 	EOF
-	gem.summary       = "An easy to use DNS server and resolver for Ruby."
-	gem.homepage      = "https://github.com/ioquatix/rubydns"
+	spec.summary       = "An easy to use DNS server and resolver for Ruby."
+	spec.homepage      = "http://www.codeotaku.com/projects/rubydns"
+	spec.license       = "MIT"
 
-	gem.files         = `git ls-files`.split($/)
-	gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-	gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-	gem.require_paths = ["lib"]
+	spec.files         = `git ls-files`.split($/)
+	spec.executables   = spec.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+	spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+	spec.require_paths = ["lib"]
+	spec.has_rdoc = "yard"
+	
+	spec.required_ruby_version = '>= 2.2.6'
 
-	gem.add_dependency("rexec", "~> 1.5.1")
-	gem.add_dependency("eventmachine", "~> 1.0.0")
-
-	gem.has_rdoc = "yard"
+	spec.add_dependency("async-dns", "~> 1.0")
+	spec.add_development_dependency("async-rspec", "~> 1.0")
+	
+	spec.add_development_dependency "bundler", "~> 1.3"
+	spec.add_development_dependency "rspec", "~> 3.4"
+	spec.add_development_dependency "rake"
 end

data/spec/rubydns/daemon_spec.rb

@@ -0,0 +1,114 @@
+#!/usr/bin/env ruby
+
+# Copyright, 2012, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'rubydns'
+require 'process/daemon'
+
+class BasicTestServer < Process::Daemon
+	SERVER_PORTS = [[:udp, '127.0.0.1', 5350], [:tcp, '127.0.0.1', 5350]]
+
+	IN = Resolv::DNS::Resource::IN
+
+	def working_directory
+		File.expand_path("../tmp", __FILE__)
+	end
+
+	def reactor
+		Async::Reactor.new
+	end
+
+	def startup
+		reactor.run do
+			RubyDNS::run_server(SERVER_PORTS) do
+				match("test.local", IN::A) do |transaction|
+					transaction.respond!("192.168.1.1")
+				end
+
+				match(/foo.*/, IN::A) do |transaction|
+					transaction.respond!("192.168.1.2")
+				end
+
+				match(/peername/, IN::A) do |transaction|
+					transaction.respond!(transaction[:remote_address].ip_address)
+				end
+
+				# Default DNS handler
+				otherwise do |transaction|
+					transaction.fail!(:NXDomain)
+				end
+			end
+		end
+	end
+	
+	def shutdown
+		@reactor.stop
+	end
+end
+
+describe "RubyDNS Daemonized Server" do
+	include_context Async::RSpec::Reactor
+	
+	before(:all) do
+		# BasicTestServer.controller output: $stderr
+		BasicTestServer.start
+	end
+	
+	after(:all) do
+		BasicTestServer.stop
+	end
+	
+	it "should resolve local domain correctly" do
+		expect(BasicTestServer.status).to be == :running
+		
+		resolver = RubyDNS::Resolver.new(BasicTestServer::SERVER_PORTS)
+	
+		response = resolver.query("test.local")
+		
+		answer = response.answer.first
+		
+		expect(answer[0].to_s).to be == "test.local."
+		expect(answer[2].address.to_s).to be == "192.168.1.1"
+	end
+	
+	it "should pattern match correctly" do
+		expect(BasicTestServer.status).to be == :running
+		
+		resolver = RubyDNS::Resolver.new(BasicTestServer::SERVER_PORTS)
+
+		response = resolver.query("foobar")
+		answer = response.answer.first
+		
+		expect(answer[0]).to be == resolver.fully_qualified_name("foobar")
+		expect(answer[2].address.to_s).to be == "192.168.1.2"
+	end
+	
+	it "should give peer ip address" do
+		expect(BasicTestServer.status).to be == :running
+		
+		resolver = RubyDNS::Resolver.new(BasicTestServer::SERVER_PORTS)
+
+		response = resolver.query("peername")
+		answer = response.answer.first
+		
+		expect(answer[2].address.to_s).to be == "127.0.0.1"
+	end
+end

data/{test/test_system.rb → spec/rubydns/injected_supervisor_spec.rb}

@@ -20,38 +20,45 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'helper'
-require 'pathname'
-
 require 'rubydns'
-require 'rubydns/system'
-
-require 'rexec'
+require 'async/dns/extensions/string'
 
-class SystemTest < Test::Unit::TestCase
-	def test_system_nameservers
-		# There technically should be at least one nameserver:
-		resolver = RubyDNS::Resolver.new(RubyDNS::System::nameservers)
-		
-		EventMachine::run do
-			resolver.query('google.com') do |response|
-				assert_equal RubyDNS::Message, response.class
-				assert_equal Resolv::DNS::RCode::NoError, response.rcode
-				
-				EventMachine::stop
-			end
+module RubyDNS::InjectedSupervisorSpec
+	class TestServer < RubyDNS::RuleBasedServer
+		def test_message
+			'Testing...'
 		end
 	end
 	
-	def test_hosts
-		hosts = RubyDNS::System::Hosts.new
+	SERVER_PORTS = [[:udp, '127.0.0.1', 5520]]
+	IN = Resolv::DNS::Resource::IN
+	
+	describe "RubyDNS::run_server(server_class: ...)" do
+		include_context Async::RSpec::Reactor
 		
-		# Load the test hosts data:
-		File.open(File.expand_path("../hosts.txt", __FILE__)) do |file|
-			hosts.parse_hosts(file)
+		let(:server) do
+			# Start the RubyDNS server
+			RubyDNS::run_server(SERVER_PORTS, server_class: TestServer) do
+				match("test_message", IN::TXT) do |transaction|
+					transaction.respond!(*test_message.chunked)
+				end
+				
+				# Default DNS handler
+				otherwise do |transaction|
+					transaction.fail!(:NXDomain)
+				end
+			end
 		end
 		
-		assert hosts.call('testing')
-		assert_equal '1.2.3.4', hosts['testing']
+		it "should use the injected class" do
+			task = server
+			
+			resolver = RubyDNS::Resolver.new(SERVER_PORTS)
+			response = resolver.query("test_message", IN::TXT)
+			text = response.answer.first
+			expect(text[2].strings.join).to be == 'Testing...'
+			
+			task.stop
+		end
 	end
 end

data/spec/rubydns/passthrough_spec.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+
+# Copyright, 2012, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'rubydns'
+
+module RubyDNS::PassthroughSpec
+	SERVER_PORTS = [[:udp, '127.0.0.1', 5340], [:tcp, '127.0.0.1', 5340]]
+	Name = Resolv::DNS::Name
+	IN = Resolv::DNS::Resource::IN
+	
+	describe "RubyDNS Passthrough Server" do
+		include_context Async::RSpec::Reactor
+		
+		def run_server
+			task = RubyDNS::run_server(listen: SERVER_PORTS) do
+				resolver = RubyDNS::Resolver.new([[:udp, "8.8.8.8", 53], [:tcp, "8.8.8.8", 53]])
+			
+				match(/.*\.com/, IN::A) do |transaction|
+					transaction.passthrough!(resolver)
+				end
+
+				match(/a-(.*\.org)/) do |transaction, match_data|
+					transaction.passthrough!(resolver, :name => match_data[1])
+				end
+
+				# Default DNS handler
+				otherwise do |transaction|
+					transaction.fail!(:NXDomain)
+				end
+			end
+			
+			yield
+			
+		ensure
+			task.stop
+		end
+		
+		it "should resolve domain correctly" do
+			run_server do
+				resolver = RubyDNS::Resolver.new(SERVER_PORTS, timeout: 1)
+				
+				response = resolver.query("google.com")
+				expect(response.ra).to be == 1
+			
+				answer = response.answer.first
+				expect(answer).not_to be == nil
+				expect(answer.count).to be > 0
+			
+				addresses = answer.select {|record| record.kind_of? Resolv::DNS::Resource::IN::A}
+				expect(addresses.size).to be > 0
+			end
+		end
+	
+		it "should resolve prefixed domain correctly" do
+			run_server do
+				resolver = RubyDNS::Resolver.new(SERVER_PORTS)
+			
+				response = resolver.query("a-slashdot.org")
+				answer = response.answer.first
+			
+				expect(answer).not_to be == nil
+				expect(answer.count).to be > 0
+			end
+		end
+	end
+end

data/spec/rubydns/rules_spec.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+# Copyright, 2012, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'rubydns'
+
+module RubyDNS::RulesSpec
+	describe RubyDNS::RuleBasedServer do
+		IN = Resolv::DNS::Resource::IN
+
+		true_callback = Proc.new { true }
+
+		it "should match string patterns correctly" do
+			server = double(:logger => Logger.new("/dev/null"))
+			transaction = double(:query => Resolv::DNS::Message.new(0))
+
+			rule = RubyDNS::RuleBasedServer::Rule.new(["foobar", IN::A], true_callback)
+
+			expect(rule.call(server, "foobar", IN::A, transaction)).to be == true
+			expect(rule.call(server, "barfoo", IN::A, transaction)).to be == false
+			expect(rule.call(server, "foobar", IN::TXT, transaction)).to be == false
+		end
+
+		it "should match regular expression patterns correctly" do
+			server = double(:logger => Logger.new("/dev/null"))
+			transaction = double(:query => Resolv::DNS::Message.new(0))
+
+			rule = RubyDNS::RuleBasedServer::Rule.new([/foo/, IN::A], true_callback)
+
+			expect(rule.call(server, "foobar", IN::A, transaction)).to be == true
+			expect(rule.call(server, "barbaz", IN::A, transaction)).to be == false
+			expect(rule.call(server, "foobar", IN::TXT, transaction)).to be == false
+		end
+
+		it "should match callback patterns correctly" do
+			server = double(:logger => Logger.new("/dev/null"))
+			transaction = double(:query => Resolv::DNS::Message.new(0))
+
+			calls = 0
+
+			callback = Proc.new do |name, resource_class|
+				# A counter used to check the number of times this block was invoked.
+				calls += 1
+	
+				name.size == 6
+			end
+
+			rule = RubyDNS::RuleBasedServer::Rule.new([callback], true_callback)
+
+			expect(rule.call(server, "foobar", IN::A, transaction)).to be == true
+			expect(rule.call(server, "foobarbaz", IN::A, transaction)).to be == false
+
+			expect(calls).to be == 2
+		end
+	end
+end