171 lines
4.4 KiB
Ruby
171 lines
4.4 KiB
Ruby
|
|
require 'test/unit'
|
|
require 'openid/yadis/accept'
|
|
require 'openid/extras'
|
|
require 'openid/util'
|
|
|
|
module OpenID
|
|
|
|
class AcceptTest < Test::Unit::TestCase
|
|
include TestDataMixin
|
|
|
|
def getTestData()
|
|
# Read the test data off of disk
|
|
#
|
|
# () -> [(int, str)]
|
|
lines = read_data_file('accept.txt')
|
|
line_no = 1
|
|
return lines.collect { |line|
|
|
pair = [line_no, line]
|
|
line_no += 1
|
|
pair
|
|
}
|
|
end
|
|
|
|
def chunk(lines)
|
|
# Return groups of lines separated by whitespace or comments
|
|
#
|
|
# [(int, str)] -> [[(int, str)]]
|
|
chunks = []
|
|
chunk = []
|
|
lines.each { |lineno, line|
|
|
stripped = line.strip()
|
|
if (stripped == '') or stripped.starts_with?('#')
|
|
if chunk.length > 0
|
|
chunks << chunk
|
|
chunk = []
|
|
end
|
|
else
|
|
chunk << [lineno, stripped]
|
|
end
|
|
}
|
|
|
|
if chunk.length > 0
|
|
chunks << chunk
|
|
end
|
|
|
|
return chunks
|
|
end
|
|
|
|
def parseLines(chunk)
|
|
# Take the given chunk of lines and turn it into a test data
|
|
# dictionary
|
|
#
|
|
# [(int, str)] -> {str:(int, str)}
|
|
items = {}
|
|
chunk.each { |lineno, line|
|
|
header, data = line.split(':', 2)
|
|
header = header.downcase
|
|
items[header] = [lineno, data.strip]
|
|
}
|
|
return items
|
|
end
|
|
|
|
def parseAvailable(available_text)
|
|
# Parse an Available: line's data
|
|
#
|
|
# str -> [str]
|
|
return available_text.split(',', -1).collect { |s| s.strip }
|
|
end
|
|
|
|
def parseExpected(expected_text)
|
|
# Parse an Expected: line's data
|
|
#
|
|
# str -> [(str, float)]
|
|
expected = []
|
|
if expected_text != ''
|
|
expected_text.split(',', -1).each { |chunk|
|
|
chunk = chunk.strip
|
|
mtype, qstuff = chunk.split(';', -1)
|
|
mtype = mtype.strip
|
|
Util.assert(!mtype.index('/').nil?)
|
|
qstuff = qstuff.strip
|
|
q, qstr = qstuff.split('=', -1)
|
|
Util.assert(q == 'q')
|
|
qval = qstr.to_f
|
|
expected << [mtype, qval]
|
|
}
|
|
end
|
|
|
|
return expected
|
|
end
|
|
|
|
def test_accept_headers
|
|
lines = getTestData()
|
|
chunks = chunk(lines)
|
|
data_sets = chunks.collect { |chunk| parseLines(chunk) }
|
|
cases = []
|
|
data_sets.each { |data|
|
|
lnos = []
|
|
lno, header = data['accept']
|
|
lnos << lno
|
|
lno, avail_data = data['available']
|
|
lnos << lno
|
|
begin
|
|
available = parseAvailable(avail_data)
|
|
rescue
|
|
print 'On line', lno
|
|
raise
|
|
end
|
|
|
|
lno, exp_data = data['expected']
|
|
lnos << lno
|
|
begin
|
|
expected = parseExpected(exp_data)
|
|
rescue
|
|
print 'On line', lno
|
|
raise
|
|
end
|
|
|
|
descr = sprintf('MatchAcceptTest for lines %s', lnos)
|
|
|
|
# Test:
|
|
accepted = Yadis.parse_accept_header(header)
|
|
actual = Yadis.match_types(accepted, available)
|
|
assert_equal(expected, actual)
|
|
|
|
assert_equal(Yadis.get_acceptable(header, available),
|
|
expected.collect { |mtype, _| mtype })
|
|
}
|
|
end
|
|
|
|
def test_generate_accept_header
|
|
# TODO: move this into a test case file and write parsing code
|
|
# for it.
|
|
|
|
# Form: [input_array, expected_header_string]
|
|
cases = [
|
|
# Empty input list
|
|
[[], ""],
|
|
# Content type name only; no q value
|
|
[["test"], "test"],
|
|
# q = 1.0 should be omitted from the header
|
|
[[["test", 1.0]], "test"],
|
|
# Test conversion of float to string
|
|
[["test", ["with_q", 0.8]], "with_q; q=0.8, test"],
|
|
# Allow string q values, too
|
|
[["test", ["with_q_str", "0.7"]], "with_q_str; q=0.7, test"],
|
|
# Test q values out of bounds
|
|
[[["test", -1.0]], nil],
|
|
[[["test", 1.1]], nil],
|
|
# Test sorting of types by q value
|
|
[[["middle", 0.5], ["min", 0.1], "max"],
|
|
"min; q=0.1, middle; q=0.5, max"],
|
|
|
|
].each { |input, expected_header|
|
|
|
|
if expected_header.nil?
|
|
assert_raise(ArgumentError) {
|
|
Yadis.generate_accept_header(*input)
|
|
}
|
|
else
|
|
assert_equal(expected_header, Yadis.generate_accept_header(*input),
|
|
[input, expected_header].inspect)
|
|
end
|
|
}
|
|
end
|
|
|
|
end
|
|
|
|
end
|