rubydns 0.8.5 → 0.9.0

data/spec/rubydns/resolver_spec.rb

@@ -0,0 +1,144 @@
+#!/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::ResolverSpec
+	describe RubyDNS::Resolver do
+		class JunkUDPServer
+			include Celluloid::IO
+	
+			def initialize
+				@socket = UDPSocket.new
+				@socket.bind("0.0.0.0", 6060)
+		
+				async.run
+			end
+	
+			finalizer :shutdown
+	
+			def finalize
+				@socket.close if @socket
+			end
+	
+			def run
+				data, (_, port, host) = @socket.recvfrom(1024)
+		
+				@socket.send("Foobar", 0, host, port)
+			end
+		end
+
+		class JunkTCPServer
+			include Celluloid::IO
+	
+			def initialize
+				@socket = TCPServer.new("0.0.0.0", 6060)
+		
+				async.run
+			end
+	
+			finalizer :shutdown
+	
+			def finalize
+				@socket.close if @socket
+			end
+	
+			def run
+				# @logger.debug "Waiting for incoming TCP connections #{@socket.inspect}..."
+				loop { async.handle_connection @socket.accept }
+			end
+	
+			def handle_connection(socket)
+				socket.write("\0\0obar")
+			ensure
+				socket.close
+			end
+		end
+
+		before(:all) do
+			Celluloid.shutdown
+			Celluloid.boot
+	
+			JunkUDPServer.supervise
+			JunkTCPServer.supervise
+		end
+
+		it "should result in non-existent domain" do
+			resolver = RubyDNS::Resolver.new([[:udp, "8.8.8.8", 53], [:tcp, "8.8.8.8", 53]])
+	
+			response = resolver.query('foobar.oriontransfer.org')
+	
+			expect(response.rcode).to be == Resolv::DNS::RCode::NXDomain
+		end
+
+		it "should result in some answers" do
+			resolver = RubyDNS::Resolver.new([[:udp, "8.8.8.8", 53], [:tcp, "8.8.8.8", 53]])
+	
+			response = resolver.query('google.com')
+	
+			expect(response.class).to be == RubyDNS::Message
+			expect(response.answer.size).to be > 0
+		end
+
+		it "should return no results" do
+			resolver = RubyDNS::Resolver.new([])
+	
+			response = resolver.query('google.com')
+	
+			expect(response).to be == nil
+		end
+
+		it "should fail to get addresses" do
+			resolver = RubyDNS::Resolver.new([])
+	
+			expect{resolver.addresses_for('google.com')}.to raise_error(RubyDNS::ResolutionFailure)
+		end
+
+		it "should fail with decode error from bad udp server" do
+			resolver = RubyDNS::Resolver.new([[:udp, "0.0.0.0", 6060]])
+			
+			response = resolver.query('google.com')
+			
+			expect(response).to be == nil
+		end
+
+		it "should fail with decode error from bad tcp server" do
+			resolver = RubyDNS::Resolver.new([[:tcp, "0.0.0.0", 6060]])
+			
+			response = resolver.query('google.com')
+			
+			expect(response).to be == nil
+		end
+
+		it "should return some IPv4 and IPv6 addresses" do
+			resolver = RubyDNS::Resolver.new([[:udp, "8.8.8.8", 53], [:tcp, "8.8.8.8", 53]])
+	
+			addresses = resolver.addresses_for("www.google.com.")
+	
+			expect(addresses.size).to be > 0
+	
+			addresses.each do |address|
+				expect(address).to be_kind_of(Resolv::IPv4) | be_kind_of(Resolv::IPv6)
+			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

data/{test/performance → spec/rubydns/server}/million.rb

@@ -56,8 +56,6 @@ StackProf.run(mode: :cpu, out: 'rubydns.stackprof') do
 		otherwise do |transaction|
 			logger.info "Passing DNS request upstream..."
 			transaction.fail!(:NXDomain)
-			
-			EventMachine::stop
 		end
 	end
 end
@@ -84,4 +82,4 @@ end
 # ;; SERVER: 127.0.0.1#5300(127.0.0.1)
 # ;; WHEN: Fri May 16 19:17:48 2014
 # ;; MSG SIZE  rcvd: 47
-# 
+# 

data/spec/rubydns/server_performance_spec.rb

@@ -0,0 +1,136 @@
+#!/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 'benchmark'
+require 'process/daemon'
+
+module RubyDNS::ServerPerformanceSpec
+	describe RubyDNS::Server do
+		context 'benchmark' do
+			class ServerPerformanceRubyDNS < Process::Daemon
+				IN = Resolv::DNS::Resource::IN
+	
+				def working_directory
+					File.expand_path("../tmp", __FILE__)
+				end
+	
+				def startup
+					puts "Booting celluloid..."
+					Celluloid.boot
+				
+					million = {}
+		
+					puts "Generating domains..."
+					(1..5_000).each do |i|
+						domain = "domain#{i}.local"
+	
+						million[domain] = "#{69}.#{(i >> 16)%256}.#{(i >> 8)%256}.#{i%256}"
+					end
+		
+					puts "Starting DNS server..."
+					RubyDNS::run_server(:listen => [[:udp, '0.0.0.0', 5300]]) do
+						@logger.level = Logger::WARN
+			
+						match(//, IN::A) do |transaction|
+							puts "Responding to #{transaction.name}"
+							transaction.respond!(million[transaction.name])
+						end
+		
+						# Default DNS handler
+						otherwise do |transaction|
+							transaction.fail!(:NXDomain)
+						end
+					end
+				end
+			end
+
+			class ServerPerformanceBind9 < Process::Daemon
+				def working_directory
+					File.expand_path("../server/bind9", __FILE__)
+				end
+	
+				def startup
+					exec(self.class.named_executable, "-c", "named.conf", "-f", "-p", "5400", "-g")
+				end
+	
+				def self.named_executable
+					# Check if named executable is available:
+					@named ||= `which named`.chomp
+				end
+			end
+		
+			before do
+				Celluloid.shutdown
+			
+				@servers = []
+				@servers << ["RubyDNS::Server", 5300]
+			
+				@domains = (1..1000).collect do |i|
+					"domain#{i}.local"
+				end
+			
+				ServerPerformanceRubyDNS.start
+			
+				unless ServerPerformanceBind9.named_executable.empty?
+					ServerPerformanceBind9.start
+					@servers << ["Bind9", 5400]
+				end
+				
+				sleep 2
+				
+				Celluloid.boot
+			end
+		
+			after do
+				ServerPerformanceRubyDNS.stop
+			
+				unless ServerPerformanceBind9.named_executable.empty?
+					ServerPerformanceBind9.stop
+				end
+			end
+		
+			it 'it takes time' do
+				Celluloid.logger.level = Logger::ERROR
+			
+				Benchmark.bm(20) do |x|
+					@servers.each do |name, port|
+						resolver = RubyDNS::Resolver.new([[:udp, '127.0.0.1', port]])
+					
+						x.report(name) do
+							# Number of requests remaining since this is an asynchronous event loop:
+							5.times do
+								pending = @domains.size
+							
+								futures = @domains.collect{|domain| resolver.future.addresses_for(domain)}
+							
+								futures.collect do |future|
+									expect(future.value).to_not be nil
+								end
+							end
+						end
+					end
+				end
+			end
+		end
+	end
+end

data/spec/rubydns/slow_server_spec.rb

@@ -0,0 +1,89 @@
+#!/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::SlowServerSpec
+	SERVER_PORTS = [[:udp, '127.0.0.1', 5330], [:tcp, '127.0.0.1', 5330]]
+	IN = Resolv::DNS::Resource::IN
+	
+	describe "RubyDNS Slow Server" do
+		before(:all) do
+			Celluloid.shutdown
+			Celluloid.boot
+		
+			@server = RubyDNS::run_server(:listen => SERVER_PORTS, asynchronous: true) do
+				match(/\.*.com/, IN::A) do |transaction|
+					sleep 2
+					
+					transaction.fail!(:NXDomain)
+				end
+
+				otherwise do |transaction|
+					transaction.fail!(:NXDomain)
+				end
+			end
+		end
+	
+		it "get no answer after 2 seconds" do
+			start_time = Time.now
+		
+			resolver = RubyDNS::Resolver.new(SERVER_PORTS, :timeout => 10)
+		
+			response = resolver.query("apple.com", IN::A)
+		
+			expect(response.answer.length).to be == 0
+		
+			end_time = Time.now
+		
+			expect(end_time - start_time).to be_within(0.1).of(2.0)
+		end
+	
+		it "times out after 1 second" do
+			start_time = Time.now
+		
+			resolver = RubyDNS::Resolver.new(SERVER_PORTS, :timeout => 0.5)
+		
+			response = resolver.query("apple.com", IN::A)
+		
+			expect(response).to be nil
+		
+			end_time = Time.now
+		
+			expect(end_time - start_time).to be_within(0.1).of(1.0)
+		end
+	
+		it "gets no answer immediately" do
+			start_time = Time.now
+		
+			resolver = RubyDNS::Resolver.new(SERVER_PORTS, :timeout => 0.5)
+		
+			response = resolver.query("oriontransfer.org", IN::A)
+		
+			expect(response.answer.length).to be 0
+		
+			end_time = Time.now
+		
+			expect(end_time - start_time).to be_within(0.1).of(0.0)
+		end
+	end
+end

data/spec/rubydns/socket_spec.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+
+# Copyright, 2014, 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 'rubydns/system'
+
+module RubyDNS::SocketSpec
+	IN = Resolv::DNS::Resource::IN
+	
+	describe RubyDNS::TCPSocketHandler do
+		before(:all) do
+			Celluloid.shutdown
+			Celluloid.boot
+		end
+	
+		it "should create server with existing TCP socket" do
+			socket = TCPServer.new('127.0.0.1', 2002)
+			
+			# Start the RubyDNS server
+			@server = RubyDNS::run_server(:listen => [socket], asynchronous: true) 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
+			end
+			
+			resolver = RubyDNS::Resolver.new([[:tcp, '127.0.0.1', 2002]])
+			response = resolver.query('google.com')
+			expect(response.class).to be == RubyDNS::Message
+		end
+	end
+	
+	describe RubyDNS::UDPSocketHandler do
+		before(:all) do
+			Celluloid.shutdown
+			Celluloid.boot
+		end
+		
+		it "should create server with existing UDP socket" do
+			socket = UDPSocket.new
+			socket.bind('127.0.0.1', 2002)
+			
+			# Start the RubyDNS server
+			@server = RubyDNS::run_server(:listen => [socket], asynchronous: true) 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
+			end
+			
+			resolver = RubyDNS::Resolver.new([[:udp, '127.0.0.1', 2002]])
+			response = resolver.query('google.com')
+			expect(response.class).to be == RubyDNS::Message
+		end
+	end
+end

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

@@ -20,35 +20,41 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'minitest/autorun'
-
 require 'rubydns'
 require 'rubydns/system'
 
-class SystemTest < MiniTest::Test
-	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::SystemSpec
+	describe RubyDNS::System do
+		before(:all) do
+			Celluloid.shutdown
+			Celluloid.boot
+		end
+	
+		it "should have at least one namesever" do
+			expect(RubyDNS::System::nameservers.length).to be > 0
 		end
-	end
 	
-	def test_hosts
-		hosts = RubyDNS::System::Hosts.new
+		it "should respond to query for google.com" do
+			resolver = RubyDNS::Resolver.new(RubyDNS::System::nameservers)
 		
-		# Load the test hosts data:
-		File.open(File.expand_path("../hosts.txt", __FILE__)) do |file|
-			hosts.parse_hosts(file)
+			response = resolver.query('google.com')
+		
+			expect(response.class).to be == RubyDNS::Message
+			expect(response.rcode).to be == Resolv::DNS::RCode::NoError
 		end
+	end
+
+	describe RubyDNS::System::Hosts do
+		it "should parse the hosts file" do
+			hosts = RubyDNS::System::Hosts.new
 		
-		assert hosts.call('testing')
-		assert_equal '1.2.3.4', hosts['testing']
+			# Load the test hosts data:
+			File.open(File.expand_path("../hosts.txt", __FILE__)) do |file|
+				hosts.parse_hosts(file)
+			end
+		
+			expect(hosts.call('testing')).to be == true
+			expect(hosts['testing']).to be == '1.2.3.4'
+		end
 	end
 end

data/spec/rubydns/transaction_spec.rb

@@ -0,0 +1,64 @@
+#!/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 'yaml'
+
+module RubyDNS::TransactionSpec
+	SERVER_PORTS = [[:udp, '8.8.8.8', 53], [:tcp, '8.8.8.8', 53]]
+	IN = Resolv::DNS::Resource::IN
+	
+	describe RubyDNS::Transaction do
+		let(:server) { RubyDNS::Server.new }
+		let(:query) { RubyDNS::Message.new(0) }
+		let(:question) { Resolv::DNS::Name.create("www.google.com") }
+		let(:response) { RubyDNS::Message.new(0) }
+		let(:resolver) { RubyDNS::Resolver.new([[:udp, '8.8.8.8', 53], [:tcp, '8.8.8.8', 53]])}
+		
+		it "should append an address" do
+			transaction = RubyDNS::Transaction.new(server, query, question, IN::A, response)
+			
+			transaction.respond!("1.2.3.4")
+			
+			expect(transaction.response.answer[0][0].to_s).to be == question.to_s
+			expect(transaction.response.answer[0][2].address.to_s).to be == "1.2.3.4"
+		end
+		
+		it "should passthrough the request" do
+			transaction = RubyDNS::Transaction.new(server, query, question, IN::A, response)
+			
+			expect(transaction.response.answer.size).to be 0
+			
+			transaction.passthrough!(resolver)
+			
+			expect(transaction.response.answer.size).to be > 0
+		end
+		
+		it "should fail the request" do
+			transaction = RubyDNS::Transaction.new(server, query, question, IN::A, response)
+			
+			transaction.fail! :NXDomain
+			
+			expect(transaction.response.rcode).to be Resolv::DNS::RCode::NXDomain
+		end
+	end
+end