require 'socket'
require 'thread'
# Boardcaster maintains a list of users.
class Broadcaster
def initialize; @users = []; end
def add user; @users << socket =" TCPServer.open(6606)" broadcaster =" Broadcaster.new" lock =" Mutex.new">")
user = {:name => s.gets.strip, :socket => s }
b.add user
print("#{user[:name]} is accepted\n")
s.write("Hello #{user[:name]}\n\rUsers on-line: #{b.list}\n\r>")
while true
st = s.gets.strip
#p st
break if st == 'bye'
lock.synchronize do
b.broadcast "#{user[:name]} says \"#{st}\"\n\r>"
end
end
lock.synchronize do
b.broadcast "#{user[:name]} has left\n\r>"
end
s.close
b.remove user
print("#{user[:name]} is gone\n")
end
end
This was my first experience of both threads and sockets on Ruby, and with regards to threads, I have to admit to being pretty clueless! However, it does seem worthwhile locking the shared resource, b, when used on a thread.
Sockets seems straightforward enough. A new socket is opened using the TCPServer class. Data is collected with gets, and sent with write. At the end it is closed. I suspect there should be some exception handling in there, but it certainly proves the concept.
Testing Stream-Handling Methods
Okay, so now I want to test my methods that handle streams. Let us suppose that you have a method that accepts data from some stream and outputs to another, like the broadcast method above, and you want to test it. How do you do it?
First, let me simplify, and instead consider this method:
def get_data source, sink
print "\n>"
name = source.gets.strip
print "\n>"
age = source.gets.strip
sink.print "Name: #{name}, age: #{age}"
end
This could be invoked for use with the keyboard like this
get_data $stdin, $stdout
Or across a network, like this:
require 'socket'
socket = TCPServer.open(6606)
get_data socket, socket
If I want to test that method the trick is to use StringIO objects.
def test_get_data1
StringIO.open { |sink|
get_data(StringIO.new("Boris\n32\n"), sink)
assert_equal "Name: Boris, age: 32", sink.string
}
end
Actually, Ruby would happily let you use the same StringIO object for both input and output, but the output would be appended to the input string, so your assertion would need to check for both the input and the output.
def test_get_data2
StringIO.open("Boris\n32\n") { |io|
get_data(io, io)
assert_equal "Boris\n32\nName: Boris, age: 32", io.string
}
end
That is bad; if we change the get_data method to accept different input, we would need to change the test in two places, and that is clearly a bad thing. Well, okay, we change it so the input gets inserted into what we expect. The problem now is that Ruby is modifying that string during the test, so we need instead to give Ruby a duplicate of the input string for it to play with, so we still have the orignal for comparison at the end.
def test_get_data3
input = "Boris\n32\n"
StringIO.open(input.clone) { |io|
get_data(io, io)
assert_equal "#{input}Name: Boris, age: 32", io.string
}
end
Then again, perhaps we need to rethink. The whole thing can be generalised into a new method, which can test any method against any input. The test itself can then be reduced to a single line.
def test_get_data4
stream_test("Boris\n32\n", "Name: Boris, age: 32") do |io|
get_data(io, io)
end
end
def stream_test input, output
StringIO.open(input.clone) { |io|
yield io
assert_equal "#{input}#{output}", io.string
}
end
A serious problem with all of these is that errors do not get caught by the test regime. A message is sent to the output, but the error is not counted in the totals (failures, on the other hand, are). I guess this is because the redirect is capturing the exception. A way around this is to capture the exception inside the block, and then flag this as a failure:
def stream_test input, output
StringIO.open(input.clone) { |io|
begin
yield io
rescue Exception => ex
assert false, "ERROR: #{ex.inspect}\n#{$!.backtrace[0..12] * "\n"}"
end
assert_equal "#{input}#{output}", io.string
}
end
Testing Multiple Threads
Those tests are all very well, but my Broadcast object sends messages to multiple users. How do I test that? Now I need threads in my tests!
Here is a test method that worked for me:
def test_broadcast
# SETTING UP
# The number of threads to spawn
number = 100
test_string = 'teststring'
b = Broadcaster.new
# Define strings outside the blocks so we can access them
# later on
string_ary = Array.new(number, '')
thread_ary = Array.new(number)
main_s = nil
# LISTENING THREADS
# A number of threads are spawned, they listen for
# messages for 0.2 seconds, then write their StringIO
# string to string_ary, before terminating.
number.times do |i|
# Spawn a new thread
thread_ary[i] = Thread.start(b, i) do
# Create a StringIO object to collect the string
StringIO.open do |sink|
# Create a new user, and add it to the Broadcaster
user = {:name => 'test1', :socket => sink }
b.add user
# Wait a short time for the message to be broadcast
# Choose wisely, 0.2 on my system led to failures
sleep(0.3)
# Set s1 to a copy of the sink string, so it
# is still around outside the block
string_ary[i] = sink.string.clone
end
end
end
# SENDING THREAD
# On the main thread, this sends the message, then waits
# for all the other threads to terminate.
# Create a StringIO object to collect the string
StringIO.open do |sink|
begin
# Create a new user, and add it to the Broadcaster
user = {:name => 'test2', :socket => sink }
b.add user
# Broadcast the test string
b.broadcast(test_string)
# Wait for the other threads to finish
# by which time the broadcast should have been received.
number.times { |i| thread_ary[i].join }
main_s = sink.string.clone
rescue Exception => ex
# Flag any exceptions as a failure
assert false, ex.inspect
end
end
# TESTING
# Test all the threads received the test_string
assert_equal test_string, main_s
number.times { |i| assert_equal test_string, string_ary[i] }
end
Struggling with Ruby: Contents Page
