mirrors/EWF
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'content_nego_review'

Browse Source 
Conflicts:
	library/network/protocol/content_negotiation/src/conneg_server_side.e
	library/network/protocol/content_negotiation/src/parsers/common_accept_header_parser.e
	library/network/protocol/content_negotiation/test/conneg_server_side_test.e
This commit is contained in:
Jocelyn FIAT
2013-10-18 21:30:10 +02:00
parent 9b329c8b8a 6f48cf80f2
commit ddd19023b0
41 changed files with 1999 additions and 1758 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
library/network/protocol/content_negotiation/test/application.e
View File

@@ -16,10 +16,10 @@ feature {NONE} -- Initialization
make
local
mime_parse : MIME_PARSE
mime_parse : HTTP_ACCEPT_MEDIA_TYPE_UTILITIES
accept : STRING
charset_parse : COMMON_ACCEPT_HEADER_PARSER
language : LANGUAGE_PARSE
charset_parse : HTTP_ANY_ACCEPT_HEADER_UTILITIES
language : HTTP_ACCEPT_LANGUAGE_UTILITIES
do
create mime_parse
-- parse_result := mime_parse.parse_mime_type ("application/xhtml;q=0.5")
@@ -59,12 +59,12 @@ feature {NONE} -- Initialization
print ("%N"+mime_parse.quality ("*/*;q=0.1", accept).out)
accept := "application/atom+xml"
print ("%N"+mime_parse.parse_mime_type (accept).out)
print ("%N"+mime_parse.media_type (accept).out)
create charset_parse
accept := "iso-8859-5"
print ("%N" + charset_parse.parse_common (accept).out)
print ("%N" + charset_parse.header (accept).out)
accept := "unicode-1-1;q=0.8"
print ("%N" + charset_parse.parse_common (accept).out)
print ("%N" + charset_parse.header (accept).out)
accept:= "iso-8859-5, unicode-1-1;q=0.8"
@@ -78,10 +78,10 @@ feature {NONE} -- Initialization
print (language.best_match (accept.split (','), "da"))
print (language.best_match (accept.split (','), "en-*"))
print ("%N"+language.parse_language_range ("da").out)
print ("%N"+language.parse_language_range ("en-gb;q=0.8").out)
print ("%N"+language.parse_language_range ("en;q=0.7").out)
print ("%N"+language.parse_language_range ("en-*").out)
print ("%N"+language.accept_language ("da").out)
print ("%N"+language.accept_language ("en-gb;q=0.8").out)
print ("%N"+language.accept_language ("en;q=0.7").out)
print ("%N"+language.accept_language ("en-*").out)
end
end

26
library/network/protocol/content_negotiation/test/common_accept_header_parser_test.e
View File

@@ -23,33 +23,31 @@ feature {NONE} -- Events
feature -- Helpers
format (a_common: COMMON_RESULTS): STRING
format (a_common: HTTP_ANY_ACCEPT): STRING
-- Representation of the current object
do
create Result.make_from_string ("(")
if attached a_common.field as t then
if attached a_common.value as t then
Result.append_string ("'" + t + "',")
end
Result.append_string (" {")
from
a_common.params.start
until
a_common.params.after
loop
Result.append ("'" + a_common.params.key_for_iteration + "':'" + a_common.params.item_for_iteration + "',");
a_common.params.forth
if attached a_common.parameters as l_parameters then
across
l_parameters as ic
loop
Result.append ("'" + ic.key + "':'" + ic.item + "',");
end
end
Result.append ("})")
end
feature -- Test routines
test_parse_charsets
do
assert ("Expected ('iso-8859-5', {'q':'1.0',})", format (parser.parse_common("iso-8859-5")).same_string("('iso-8859-5', {'q':'1.0',})") )
assert ("Expected ('unicode-1-1', {'q':'0.8',})", format (parser.parse_common("unicode-1-1;q=0.8")).same_string("('unicode-1-1', {'q':'0.8',})") )
assert ("Expected ('*', {'q':'1.0',})", format (parser.parse_common("*")).same_string("('*', {'q':'1.0',})") )
assert ("Expected ('iso-8859-5', {'q':'1.0',})", format (parser.header("iso-8859-5")).same_string("('iso-8859-5', {'q':'1.0',})") )
assert ("Expected ('unicode-1-1', {'q':'0.8',})", format (parser.header("unicode-1-1;q=0.8")).same_string("('unicode-1-1', {'q':'0.8',})") )
assert ("Expected ('*', {'q':'1.0',})", format (parser.header("*")).same_string("('*', {'q':'1.0',})") )
end
@@ -74,6 +72,6 @@ feature -- Test routines
assert ("Expected unicode-1-1", parser.best_match (charset_supported, "unicode-1-1;q=1").same_string ("unicode-1-1"))
end
parser : COMMON_ACCEPT_HEADER_PARSER
parser : HTTP_ANY_ACCEPT_HEADER_UTILITIES
end

194
library/network/protocol/content_negotiation/test/conneg_server_side_test.e
View File

@@ -24,7 +24,7 @@ feature {NONE} -- Events
feature -- Test routines
test_media_type_negotiation
local
media_variants : MEDIA_TYPE_VARIANT_RESULTS
media_variants : HTTP_ACCEPT_MEDIA_TYPE_VARIANTS
mime_types_supported : LIST [STRING]
l_types : STRING
do
@@ -33,24 +33,28 @@ feature -- Test routines
mime_types_supported := l_types.split(',')
media_variants := conneg.media_type_preference (mime_types_supported, "text/html")
assert ("Expected Not Acceptable", not media_variants.is_acceptable)
assert ("Same Value at 1",mime_types_supported.at (1).is_equal (media_variants.supported_variants.at (1)))
assert ("Same count",mime_types_supported.count = media_variants.supported_variants.count)
assert ("Variant header is void",media_variants.variant_header = Void)
assert ("Media type is void",media_variants.type = Void)
if attached media_variants.supported_variants as l_supported_variants then
assert ("Same Value at 1", same_text (first_of (mime_types_supported), first_of (l_supported_variants)))
assert ("Same count", count_of (mime_types_supported) = count_of (l_supported_variants))
else
assert ("Has supported_variants results", False)
end
assert ("Variant Header", attached media_variants.vary_header_value as l_variant_header and then l_variant_header.same_string ("Accept"))
assert ("Media type is void",media_variants.media_type = Void)
-- Scenario 2, the client doesnt send values in the header, Accept:
media_variants := conneg.media_type_preference (mime_types_supported, "")
assert ("Expected Acceptable", media_variants.is_acceptable)
assert ("Variants is dettached",media_variants.supported_variants = Void)
assert ("Mime is defaul", conneg.mime_default.is_equal (media_variants.type))
assert ("Variant header", media_variants.variant_header = Void)
assert ("Variants is set",media_variants.supported_variants = mime_types_supported)
assert ("Mime is default", attached media_variants.media_type as l_media_type and then conneg.default_media_type.same_string (l_media_type))
assert ("Variant header", media_variants.vary_header_value = Void)
--Scenario 3, the server select the best match, and set the vary header
media_variants := conneg.media_type_preference (mime_types_supported, "text/*,application/json;q=0.5")
media_variants := conneg.media_type_preference (mime_types_supported, "text/*,application/xml;q=0.5,application/json;q=0.6")
assert ("Expected Acceptable", media_variants.is_acceptable)
assert ("Variants is dettached",media_variants.supported_variants = Void)
assert ("Variant Header", media_variants.variant_header.is_equal ("Accept"))
assert ("Media Type is application/json", media_variants.type.is_equal ("application/json"))
assert ("Variants is set",media_variants.supported_variants = mime_types_supported)
assert ("Variant Header", attached media_variants.vary_header_value as l_variant_header and then l_variant_header.same_string ("Accept"))
assert ("Media Type is application/json", attached media_variants.media_type as l_media_type and then l_media_type.same_string ("application/json"))
end
@@ -58,40 +62,44 @@ feature -- Test routines
test_charset_negotiation
local
charset_variants : CHARACTER_ENCODING_VARIANT_RESULTS
charset_variants : HTTP_ACCEPT_CHARSET_VARIANTS
charset_supported : LIST [STRING]
l_charset : STRING
l_charset_value : STRING
do
-- Scenario 1, the server side does not support client preferences
l_charset := "UTF-8, iso-8859-5"
charset_supported := l_charset.split(',')
l_charset_value := "UTF-8, iso-8859-5"
charset_supported := l_charset_value.split(',')
charset_variants := conneg.charset_preference (charset_supported, "unicode-1-1")
assert ("Expected Not Acceptable", not charset_variants.is_acceptable)
assert ("Same Value at 1",charset_supported.at (1).is_equal (charset_variants.supported_variants.at (1)))
assert ("Same count",charset_supported.count = charset_variants.supported_variants.count)
assert ("Variant header is void",charset_variants.variant_header = Void)
assert ("Character type is void",charset_variants.type = Void)
if attached charset_variants.supported_variants as l_supported_variants then
assert ("Same Value at 1", same_text (first_of (charset_supported), first_of (l_supported_variants)))
assert ("Same count",charset_supported.count = count_of (l_supported_variants))
else
assert("Has supported_variants results", False)
end
assert ("Variant Header", attached charset_variants.vary_header_value as l_variant_header and then l_variant_header.same_string ("Accept-Charset"))
assert ("Character type is void",charset_variants.charset = Void)
-- Scenario 2, the client doesnt send values in the header, Accept-Charset:
charset_variants := conneg.charset_preference (charset_supported, "")
assert ("Expected Acceptable", charset_variants.is_acceptable)
assert ("Variants is dettached",charset_variants.supported_variants = Void)
assert ("Charset is defaul", conneg.charset_default.is_equal (charset_variants.type))
assert ("Variant header", charset_variants.variant_header = Void)
assert ("Variants is set",charset_variants.supported_variants = charset_supported)
assert ("Charset is default", attached charset_variants.charset as l_charset and then conneg.default_charset.same_string (l_charset))
assert ("Variant header", charset_variants.vary_header_value = Void)
--Scenario 3, the server select the best match, and set the vary header
charset_variants := conneg.charset_preference (charset_supported, "unicode-1-1, UTF-8;q=0.3, iso-8859-5")
assert ("Expected Acceptable", charset_variants.is_acceptable)
assert ("Variants is dettached",charset_variants.supported_variants = Void)
assert ("Variant Header", charset_variants.variant_header.is_equal ("Accept-Charset"))
assert ("Character Type is iso-8859-5", charset_variants.type.is_equal ("iso-8859-5"))
assert ("Variants is set",charset_variants.supported_variants = charset_supported)
assert ("Variant Header", attached charset_variants.vary_header_value as l_variant_header and then l_variant_header.same_string ("Accept-Charset"))
assert ("Character Type is iso-8859-5", attached charset_variants.charset as l_charset and then l_charset.same_string ("iso-8859-5"))
end
test_compression_negotiation
local
compression_variants : COMPRESSION_VARIANT_RESULTS
compression_variants : HTTP_ACCEPT_ENCODING_VARIANTS
compression_supported : LIST [STRING]
l_compression : STRING
do
@@ -100,91 +108,90 @@ feature -- Test routines
compression_supported := l_compression.split(',')
compression_variants := conneg.encoding_preference (compression_supported, "gzip")
assert ("Expected Not Acceptable", not compression_variants.is_acceptable)
assert ("Same Value at 1",compression_supported.at (1).is_equal (compression_variants.supported_variants.at (1)))
assert ("Same count",compression_supported.count = compression_variants.supported_variants.count)
assert ("Variant header is void",compression_variants.variant_header = Void)
assert ("Compression type is void",compression_variants.type = Void)
if attached compression_variants.supported_variants as l_supported_variants then
assert ("Same Value at 1", same_text (first_of (compression_supported), first_of (l_supported_variants)))
assert ("Same count",compression_supported.count = count_of (l_supported_variants))
else
assert ("Has supported_variants results", False)
end
assert ("Variant Header", attached compression_variants.vary_header_value as l_variant_header and then l_variant_header.same_string ("Accept-Encoding"))
assert ("Compression type is void",compression_variants.encoding = Void)
-- Scenario 2, the client doesnt send values in the header, Accept-Encoding
compression_variants := conneg.encoding_preference (compression_supported, "")
assert ("Expected Acceptable", compression_variants.is_acceptable)
assert ("Variants is dettached",compression_variants.supported_variants = Void)
assert ("Compression is defaul", conneg.encoding_default.is_equal (compression_variants.type))
assert ("Variant header", compression_variants.variant_header = Void)
assert ("Variants is set",compression_variants.supported_variants = compression_supported)
assert ("Compression is default", attached compression_variants.encoding as l_encoding and then conneg.default_encoding.same_string (l_encoding))
assert ("Variant header", compression_variants.vary_header_value = Void)
--Scenario 3, the server select the best match, and set the vary header
l_compression := "gzip"
compression_supported := l_compression.split(',')
conneg.set_encoding_default("gzip")
conneg.set_default_encoding("gzip")
compression_variants := conneg.encoding_preference (compression_supported, "compress,gzip;q=0.7")
assert ("Expected Acceptable", compression_variants.is_acceptable)
assert ("Variants is dettached",compression_variants.supported_variants = Void)
assert ("Variant Header", compression_variants.variant_header.is_equal ("Accept-Encoding"))
assert ("Encoding Type is gzip", compression_variants.type.is_equal ("gzip"))
assert ("Variants is set",compression_variants.supported_variants = compression_supported)
assert ("Variant Header", attached compression_variants.vary_header_value as l_variant_header and then l_variant_header.same_string ("Accept-Encoding"))
assert ("Encoding Type is gzip", attached compression_variants.encoding as l_type and then l_type.same_string ("gzip"))
-- Scenario 4, the server set `identity' and the client doesn't mention identity
l_compression := "identity"
compression_supported := l_compression.split(',')
conneg.set_encoding_default("gzip")
conneg.set_default_encoding ("gzip")
compression_variants := conneg.encoding_preference (compression_supported, "gzip;q=0.7")
assert ("Expected Acceptable", compression_variants.is_acceptable)
assert ("Variants is dettached",compression_variants.supported_variants = Void)
assert ("Variant Header", compression_variants.variant_header.is_equal ("Accept-Encoding"))
assert ("Encoding Type is identity", compression_variants.type.is_equal ("identity"))
assert ("Expected Not Acceptable", not compression_variants.is_acceptable)
assert ("Variants is set",compression_variants.supported_variants = compression_supported)
assert ("Variant Header", attached compression_variants.vary_header_value as l_variant_header and then l_variant_header.same_string ("Accept-Encoding"))
assert ("Encoding Type is Void", compression_variants.encoding = Void)
-- Scenario 5, the server set `identity' and the client mention identity,q=0
l_compression := "identity"
compression_supported := l_compression.split(',')
conneg.set_encoding_default("gzip")
conneg.set_default_encoding ("gzip")
compression_variants := conneg.encoding_preference (compression_supported, "identity;q=0")
assert ("Expected Not Acceptable", not compression_variants.is_acceptable)
assert ("Variants is attached",attached compression_variants.supported_variants )
assert ("Variant Header is void", compression_variants.variant_header = Void)
assert ("Encoding Type is Void", compression_variants.type = Void)
assert ("Variant Header", attached compression_variants.vary_header_value as l_variant_header and then l_variant_header.same_string ("Accept-Encoding"))
assert ("Encoding Type is Void", compression_variants.encoding = Void)
-- Scenario 6, the server set `identity' and the client mention *,q=0
l_compression := "identity"
compression_supported := l_compression.split(',')
conneg.set_encoding_default("gzip")
conneg.set_default_encoding ("gzip")
compression_variants := conneg.encoding_preference (compression_supported, "*;q=0")
assert ("Expected Not Acceptable", not compression_variants.is_acceptable)
assert ("Variants is attached",attached compression_variants.supported_variants )
assert ("Variant Header is void", compression_variants.variant_header = Void)
assert ("Encoding Type is Void", compression_variants.type = Void)
assert ("Variant Header", attached compression_variants.vary_header_value as l_variant_header and then l_variant_header.same_string ("Accept-Encoding"))
assert ("Encoding Type is Void", compression_variants.encoding = Void)
-- Scenario 7, the server set `identity' and the client mention identity;q=0.5, gzip;q=0.7,compress
l_compression := "identity"
compression_supported := l_compression.split(',')
conneg.set_encoding_default("gzip")
conneg.set_default_encoding ("gzip")
compression_variants := conneg.encoding_preference (compression_supported, "identity;q=0.5, gzip;q=0.7,compress")
assert ("Expected Acceptable",compression_variants.is_acceptable)
assert ("Variants is void",compression_variants.supported_variants = Void)
assert ("Variant Header", compression_variants.variant_header.is_equal ("Accept-Encoding"))
assert ("Encoding Type is identity", compression_variants.type.is_equal ("identity"))
assert ("Variants is set",compression_variants.supported_variants = compression_supported)
assert ("Variant Header", attached compression_variants.vary_header_value as l_variant_header and then l_variant_header.same_string ("Accept-Encoding"))
assert ("Encoding Type is identity", attached compression_variants.encoding as l_type and then l_type.same_string ("identity"))
-- Scenario 8, the server set `identity' and the client mention identity;q=0.5
l_compression := "identity"
compression_supported := l_compression.split(',')
conneg.set_encoding_default("gzip")
conneg.set_default_encoding ("gzip")
compression_variants := conneg.encoding_preference (compression_supported, "identity;q=0.5")
assert ("Expected Acceptable",compression_variants.is_acceptable)
assert ("Variants is void",compression_variants.supported_variants = Void)
assert ("Variant Header", compression_variants.variant_header.is_equal ("Accept-Encoding"))
assert ("Encoding Type is identity", compression_variants.type.is_equal ("identity"))
assert ("Variants is set",compression_variants.supported_variants = compression_supported)
assert ("Variant Header", attached compression_variants.vary_header_value as l_variant_header and then l_variant_header.same_string ("Accept-Encoding"))
assert ("Encoding Type is identity", attached compression_variants.encoding as l_type and then l_type.same_string ("identity"))
end
test_language_negotiation
local
language_variants : LANGUAGE_VARIANT_RESULTS
language_variants : HTTP_ACCEPT_LANGUAGE_VARIANTS
languages_supported : LIST [STRING]
l_languages : STRING
do
@@ -193,30 +200,61 @@ feature -- Test routines
languages_supported := l_languages.split(',')
language_variants := conneg.language_preference (languages_supported, "de")
assert ("Expected Not Acceptable", not language_variants.is_acceptable)
assert ("Same Value at 1",languages_supported.at (1).is_equal (language_variants.supported_variants.at (1)))
assert ("Same count",languages_supported.count = language_variants.supported_variants.count)
assert ("Variant header is void",language_variants.variant_header = Void)
assert ("Language type is void",language_variants.type = Void)
assert ("Variant Header", attached language_variants.vary_header_value as l_variant_header and then l_variant_header.same_string ("Accept-Language"))
assert ("Language type is Void",language_variants.language = Void)
if attached language_variants.supported_variants as l_supported_variants then
assert ("Same Value at 1", same_text (first_of (languages_supported), first_of (l_supported_variants)))
assert ("Same count",languages_supported.count = count_of (l_supported_variants))
else
assert ("Has supported variants results", False)
end
-- Scenario 2, the client doesnt send values in the header, Accept-Language:
language_variants := conneg.language_preference (languages_supported, "")
assert ("Expected Acceptable", language_variants.is_acceptable)
assert ("Variants is dettached",language_variants.supported_variants = Void)
assert ("Language is defaul", conneg.language_default.is_equal (language_variants.type))
assert ("Variant header", language_variants.variant_header = Void)
assert ("Variants is attached",language_variants.supported_variants = languages_supported)
assert ("Language is default", attached language_variants.language as l_lang and then conneg.default_language.same_string (l_lang))
assert ("Variant header", language_variants.vary_header_value = Void)
--Scenario 3, the server select the best match, and set the vary header
language_variants := conneg.language_preference (languages_supported, "fr,es;q=0.4")
assert ("Expected Acceptable", language_variants.is_acceptable)
assert ("Variants is dettached",language_variants.supported_variants = Void)
assert ("Variant Header", language_variants.variant_header.is_equal ("Accept-Language"))
assert ("Language Type is fr", language_variants.type.is_equal ("fr"))
assert ("Variants is detached",language_variants.supported_variants = languages_supported)
assert ("Variant Header", attached language_variants.vary_header_value as l_variant_header and then l_variant_header.same_string ("Accept-Language"))
assert ("Language Type is fr", attached language_variants.language as l_lang and then l_lang.same_string ("fr"))
end
feature -- Implementation
conneg : CONNEG_SERVER_SIDE
conneg : SERVER_CONTENT_NEGOTIATION
same_text (s1,s2: detachable READABLE_STRING_8): BOOLEAN
do
if s1 = Void then
Result := s2 = Void
elseif s2 = Void then
Result := False
else
Result := s1.same_string (s2)
end
end
count_of (i: ITERABLE [READABLE_STRING_8]): INTEGER
do
across
i as ic
loop
Result := Result + 1
end
end
first_of (i: ITERABLE [READABLE_STRING_8]): detachable READABLE_STRING_8
do
across
i as ic
until
ic.item /= Void
loop
end
end
end

79
library/network/protocol/content_negotiation/test/language_parser_test.e
View File

@@ -23,25 +23,22 @@ feature {NONE} -- Events
feature -- Helpers
format (a_language: LANGUAGE_RESULTS): STRING
format (a_language: HTTP_ACCEPT_LANGUAGE): STRING
-- Representation of the current object
do
create Result.make_from_string ("(")
if attached a_language.type as t then
if attached a_language.language as t then
Result.append_string ("'" + t + "',")
end
if attached a_language.sub_type as st then
if attached a_language.specialization as st then
Result.append_string (" '" + st + "',")
end
Result.append_string (" {")
if attached a_language.params as l_params then
from
l_params.start
until
l_params.after
if attached a_language.parameters as l_params then
across
l_params as ic
loop
Result.append ("'" + l_params.key_for_iteration + "':'"+ l_params.item_for_iteration + "',");
l_params.forth
Result.append ("'" + ic.key + "':'"+ ic.item + "',");
end
end
Result.append ("})")
@@ -52,10 +49,10 @@ feature -- Test routines
test_parse_language
do
assert ("Expected ('da', {'q':'1.0',})", format (parser.parse_language_range ("da")).same_string ("('da', {'q':'1.0',})"));
assert ("Expected ('en', 'gb', {'q':'0.8',})", format (parser.parse_language_range ("en-gb;q=0.8")).same_string ("('en', 'gb', {'q':'0.8',})"));
assert ("Expected ('en', {'q':'0.7',})", format (parser.parse_language_range ("en;q=0.7")).same_string ("('en', {'q':'0.7',})"));
assert ("Expected ('en', '*', {'q':'1.0',})", format (parser.parse_language_range ("en-*")).same_string ("('en', '*', {'q':'1.0',})"));
assert ("Expected ('da', {'q':'1.0',})", format (parser.accept_language ("da")).same_string ("('da', {'q':'1.0',})"));
assert ("Expected ('en', 'gb', {'q':'0.8',})", format (parser.accept_language ("en-gb;q=0.8")).same_string ("('en', 'gb', {'q':'0.8',})"));
assert ("Expected ('en', {'q':'0.7',})", format (parser.accept_language ("en;q=0.7")).same_string ("('en', {'q':'0.7',})"));
assert ("Expected ('en', '*', {'q':'1.0',})", format (parser.accept_language ("en-*")).same_string ("('en', '*', {'q':'1.0',})"));
end
@@ -73,53 +70,53 @@ feature -- Test routines
test_best_match
local
mime_types_supported : LIST [STRING]
langs_supported : LIST [STRING]
l_types : STRING
do
l_types := "en-gb,en-us"
mime_types_supported := l_types.split(',')
assert ("Expected en-us", parser.best_match (mime_types_supported, "en-us").same_string ("en-us"))
assert ("Direct match with a q parameter", parser.best_match (mime_types_supported, "en-gb;q=1").same_string ("en-gb"))
assert ("Direct match second choice with a q parameter", parser.best_match (mime_types_supported, "en-us;q=1").same_string ("en-us"))
assert ("Direct match using a subtype wildcard", parser.best_match (mime_types_supported, "en-*;q=1").is_equal ("en-gb"))
assert ("Match using a type wildcard", parser.best_match (mime_types_supported, "*").same_string ("en-gb"))
langs_supported := l_types.split(',')
assert ("Expected en-us", parser.best_match (langs_supported, "en-us").same_string ("en-us"))
assert ("Direct match with a q parameter", parser.best_match (langs_supported, "en-gb;q=1").same_string ("en-gb"))
assert ("Direct match second choice with a q parameter", parser.best_match (langs_supported, "en-us;q=1").same_string ("en-us"))
assert ("Direct match using a subtype wildcard", parser.best_match (langs_supported, "en-*;q=1").is_equal ("en-gb"))
assert ("Match using a type wildcard", parser.best_match (langs_supported, "*").same_string ("en-gb"))
l_types := "en-gb,es"
mime_types_supported := l_types.split(',')
assert ("Match using a type versus a lower weighted subtype", parser.best_match (mime_types_supported, "es-*;q=0.5,*;q=0.1").same_string ("es"))
assert ("Fail to match anything",parser.best_match (mime_types_supported, "fr; q=0.9").same_string (""))
langs_supported := l_types.split(',')
assert ("Match using a type versus a lower weighted subtype", parser.best_match (langs_supported, "es-*;q=0.5,*;q=0.1").same_string ("es"))
assert ("Fail to match anything",parser.best_match (langs_supported, "fr; q=0.9").same_string (""))
l_types := "en-gb,en-us"
mime_types_supported := l_types.split(',')
assert ("Test 1 verify fitness ordering", parser.best_match (mime_types_supported, "en-gb,en-us,*").same_string ("en-gb"))
langs_supported := l_types.split(',')
assert ("Test 1 verify fitness ordering", parser.best_match (langs_supported, "en-gb,en-us,*").same_string ("en-gb"))
l_types := "es,en-gb;q=1.0,fr;q=0.6"
mime_types_supported := l_types.split(',')
assert ("Match default es at first position", parser.best_match (mime_types_supported, "es;q=1.0,*;q=0.1,fr").same_string ("es"))
langs_supported := l_types.split(',')
assert ("Match default es at first position", parser.best_match (langs_supported, "es;q=1.0,*;q=0.1,fr").same_string ("es"))
l_types := "en-gb;q=1.0,fr;q=0.6,es"
mime_types_supported := l_types.split(',')
assert ("Match default es at last position", parser.best_match (mime_types_supported, "es;q=1.0,*;q=0.1,fr").same_string ("es"))
langs_supported := l_types.split(',')
assert ("Match default es at last position", parser.best_match (langs_supported, "es;q=1.0,*;q=0.1,fr").same_string ("es"))
l_types := "en-gb;q=1.0,fr,es"
mime_types_supported := l_types.split(',')
assert ("Match first top quality and fitness", parser.best_match (mime_types_supported, "es;q=1.0,*;q=0.1,fr").same_string ("es"))
langs_supported := l_types.split(',')
assert ("Match first top quality and fitness", parser.best_match (langs_supported, "es;q=1.0,*;q=0.1,fr").same_string ("es"))
l_types := "fr;q=1.0,en,es"
mime_types_supported := l_types.split(',')
assert ("Test 1", parser.best_match (mime_types_supported, "es;q=1.0,*/*;q=0.1,en;q=0.9").same_string ("es"))
langs_supported := l_types.split(',')
assert ("Test 1", parser.best_match (langs_supported, "es;q=1.0,*/*;q=0.1,en;q=0.9").same_string ("es"))
l_types := "fr;q=1.0,en,es"
mime_types_supported := l_types.split(',')
assert ("Test 1", parser.best_match (mime_types_supported, "es,*/*;q=0.1,en").same_string ("es"))
langs_supported := l_types.split(',')
assert ("Test 1", parser.best_match (langs_supported, "es,*/*;q=0.1,en").same_string ("es"))
l_types := "fr;q=1.0,en,es"
mime_types_supported := l_types.split(',')
assert ("Test 2", parser.best_match (mime_types_supported, "en,es,*/*;q=0.1").same_string ("en"))
langs_supported := l_types.split(',')
assert ("Test 2", parser.best_match (langs_supported, "en,es,*/*;q=0.1").same_string ("en"))
l_types := "es,en;q=0.6"
mime_types_supported := l_types.split(',')
assert ("Test 2", parser.best_match (mime_types_supported, "fr;q=1.0, en;q=0.6, es").same_string ("es"))
langs_supported := l_types.split(',')
assert ("Test 2", parser.best_match (langs_supported, "fr;q=1.0, en;q=0.6, es").same_string ("es"))
end
@@ -137,7 +134,7 @@ feature -- Test routines
parser : LANGUAGE_PARSE
parser : HTTP_ACCEPT_LANGUAGE_UTILITIES
end

25
library/network/protocol/content_negotiation/test/mime_parser_test.e
View File

@@ -38,13 +38,10 @@ feature -- Helper
end
Result.append_string (" {")
if attached a_mediatype.parameters as l_params then
from
l_params.start
until
l_params.after
across
l_params as ic
loop
Result.append ("'" + l_params.key_for_iteration + "':'" + l_params.item_for_iteration + "',");
l_params.forth
Result.append ("'" + ic.key + "':'" + ic.item + "',");
end
end
Result.append ("})")
@@ -54,15 +51,15 @@ feature -- Test routines
test_parse_media_range
do
assert ("Expected ('application', 'xml', {'q':'1',})", format (parser.parse_media_range("application/xml;q=1")).same_string("('application', 'xml', {'q':'1.0',})") )
assert ("Expected ('application', 'xml', {'q':'1',})", format (parser.media_type("application/xml;q=1")).same_string("('application', 'xml', {'q':'1.0',})") )
assert ("Expected ('application', 'xml', {'q':'1',})", format (parser.parse_media_range("application/xml")).same_string("('application', 'xml', {'q':'1.0',})") )
assert ("Expected ('application', 'xml', {'q':'1',})", format (parser.parse_media_range("application/xml;q=")).same_string("('application', 'xml', {'q':'1.0',})") )
assert ("Expected ('application', 'xml', {'q':'1',})", format (parser.parse_media_range("application/xml ; q=")).same_string("('application', 'xml', {'q':'1.0',})") )
assert ("Expected ('application', 'xml', {'q':'1','b':'other',})", format (parser.parse_media_range("application/xml ; q=1;b=other")).same_string("('application', 'xml', {'q':'1.0','b':'other',})") )
assert ("Expected ('application', 'xml', {'q':'1','b':'other',})", format (parser.parse_media_range("application/xml ; q=2;b=other")).same_string("('application', 'xml', {'q':'1.0','b':'other',})") )
assert ("Expected ('application', 'xml', {'q':'1',})", format (parser.media_type("application/xml")).same_string("('application', 'xml', {'q':'1.0',})") )
assert ("Expected ('application', 'xml', {'q':'1',})", format (parser.media_type("application/xml;q=")).same_string("('application', 'xml', {'q':'1.0',})") )
assert ("Expected ('application', 'xml', {'q':'1',})", format (parser.media_type("application/xml ; q=")).same_string("('application', 'xml', {'q':'1.0',})") )
assert ("Expected ('application', 'xml', {'q':'1','b':'other',})", format (parser.media_type("application/xml ; q=1;b=other")).same_string("('application', 'xml', {'q':'1.0','b':'other',})") )
assert ("Expected ('application', 'xml', {'q':'1','b':'other',})", format (parser.media_type("application/xml ; q=2;b=other")).same_string("('application', 'xml', {'q':'1.0','b':'other',})") )
-- Accept header that includes *
assert ("Expected ('*', '*', {'q':'.2',})", format (parser.parse_media_range(" *; q=.2")).same_string("('*', '*', {'q':'.2',})"))
assert ("Expected ('*', '*', {'q':'.2',})", format (parser.media_type(" *; q=.2")).same_string("('*', '*', {'q':'.2',})"))
end
@@ -148,7 +145,7 @@ feature -- Test routines
parser : MIME_PARSE
parser : HTTP_ACCEPT_MEDIA_TYPE_UTILITIES
end

12
library/network/protocol/content_negotiation/test/test-safe.ecf
View File

@@ -1,19 +1,23 @@
<?xml version="1.0" encoding="ISO-8859-1"?>
<system xmlns="http://www.eiffel.com/developers/xml/configuration-1-6-0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.eiffel.com/developers/xml/configuration-1-6-0 http://www.eiffel.com/developers/xml/configuration-1-6-0.xsd" name="test" uuid="7860561C-779A-4E45-A7B9-06A1E0E984E8">
<system xmlns="http://www.eiffel.com/developers/xml/configuration-1-11-0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.eiffel.com/developers/xml/configuration-1-11-0 http://www.eiffel.com/developers/xml/configuration-1-11-0.xsd" name="test" uuid="7860561C-779A-4E45-A7B9-06A1E0E984E8">
<target name="test">
<root class="APPLICATION" feature="make"/>
<file_rule>
<exclude>/.git$</exclude>
<exclude>/EIFGENs$</exclude>
<exclude>/CVS$</exclude>
<exclude>/.svn$</exclude>
<exclude>/.git$</exclude>
</file_rule>
<option warning="true">
<option warning="true" full_class_checking="true" is_attached_by_default="true" void_safety="transitional" syntax="transitional">
<assertions precondition="true" postcondition="true" check="true" invariant="true" loop="true" supplier_precondition="true"/>
</option>
<library name="base" location="$ISE_LIBRARY\library\base\base-safe.ecf"/>
<library name="conneg" location="..\conneg-safe.ecf" readonly="false">
<option>
<assertions precondition="true" postcondition="true" check="true" invariant="true" supplier_precondition="true"/>
</option>
</library>
<library name="http" location="..\..\http\http-safe.ecf" readonly="false"/>
<library name="conneg" location="..\conneg-safe.ecf"/>
<library name="testing" location="$ISE_LIBRARY\library\testing\testing-safe.ecf"/>
<cluster name="test" location=".\" recursive="true"/>
</target>