PageRenderTime 52ms CodeModel.GetById 17ms RepoModel.GetById 0ms app.codeStats 0ms

/actionpack/test/dispatch/request_test.rb

http://github.com/rails/rails
Ruby | 1295 lines | 1129 code | 163 blank | 3 comment | 7 complexity | 67b5357bf39c972290e12d0ea1be9dab MD5 | raw file
    

  1. # frozen_string_literal: true
    2. 

  2. 

  3. require "abstract_unit"
    4. 

  4. 

  5. class BaseRequestTest < ActiveSupport::TestCase
    6. 

  6.   def setup
    7. 

  7.     @env = {
    8. 

  8.       :ip_spoofing_check => true,
    9. 

  9.       "rack.input" => "foo"
    10. 

  10.     }
    11. 

  11.     @original_tld_length = ActionDispatch::Http::URL.tld_length
    12. 

  12.   end
    13. 

  13. 

  14.   def teardown
    15. 

  15.     ActionDispatch::Http::URL.tld_length = @original_tld_length
    16. 

  16.   end
    17. 

  17. 

  18.   def url_for(options = {})
    19. 

  19.     options = { host: "www.example.com" }.merge!(options)
    20. 

  20.     ActionDispatch::Http::URL.url_for(options)
    21. 

  21.   end
    22. 

  22. 

  23.   private
    24. 

  24.     def stub_request(env = {})
    25. 

  25.       ip_spoofing_check = env.key?(:ip_spoofing_check) ? env.delete(:ip_spoofing_check) : true
    26. 

  26.       @trusted_proxies ||= nil
    27. 

  27.       ip_app = ActionDispatch::RemoteIp.new(Proc.new { }, ip_spoofing_check, @trusted_proxies)
    28. 

  28.       ActionDispatch::Http::URL.tld_length = env.delete(:tld_length) if env.key?(:tld_length)
    29. 

  29. 

  30.       ip_app.call(env)
    31. 

  31. 

  32.       env = @env.merge(env)
    33. 

  33.       ActionDispatch::Request.new(env)
    34. 

  34.     end
    35. 

  35. end
    36. 

  36. 

  37. class RequestUrlFor < BaseRequestTest
    38. 

  38.   test "url_for class method" do
    39. 

  39.     e = assert_raise(ArgumentError) { url_for(host: nil) }
    40. 

  40.     assert_match(/Please provide the :host parameter/, e.message)
    41. 

  41. 

  42.     assert_equal "/books", url_for(only_path: true, path: "/books")
    43. 

  43. 

  44.     assert_equal "http://www.example.com/books/?q=code", url_for(trailing_slash: true, path: "/books?q=code")
    45. 

  45.     assert_equal "http://www.example.com/books/?spareslashes=////", url_for(trailing_slash: true, path: "/books?spareslashes=////")
    46. 

  46. 

  47.     assert_equal "http://www.example.com",  url_for
    48. 

  48.     assert_equal "http://api.example.com",  url_for(subdomain: "api")
    49. 

  49.     assert_equal "http://example.com",      url_for(subdomain: false)
    50. 

  50.     assert_equal "http://www.ror.com",      url_for(domain: "ror.com")
    51. 

  51.     assert_equal "http://api.ror.co.uk",    url_for(host: "www.ror.co.uk", subdomain: "api", tld_length: 2)
    52. 

  52.     assert_equal "http://www.example.com:8080",   url_for(port: 8080)
    53. 

  53.     assert_equal "https://www.example.com",       url_for(protocol: "https")
    54. 

  54.     assert_equal "http://www.example.com/docs",   url_for(path: "/docs")
    55. 

  55.     assert_equal "http://www.example.com#signup", url_for(anchor: "signup")
    56. 

  56.     assert_equal "http://www.example.com/",       url_for(trailing_slash: true)
    57. 

  57.     assert_equal "http://dhh:supersecret@www.example.com", url_for(user: "dhh", password: "supersecret")
    58. 

  58.     assert_equal "http://www.example.com?search=books",    url_for(params: { search: "books" })
    59. 

  59.     assert_equal "http://www.example.com?params=",  url_for(params: "")
    60. 

  60.     assert_equal "http://www.example.com?params=1", url_for(params: 1)
    61. 

  61.   end
    62. 

  62. end
    63. 

  63. 

  64. class RequestIP < BaseRequestTest
    65. 

  65.   test "remote ip" do
    66. 

  66.     request = stub_request "REMOTE_ADDR" => "1.2.3.4"
    67. 

  67.     assert_equal "1.2.3.4", request.remote_ip
    68. 

  68. 

  69.     request = stub_request "REMOTE_ADDR" => "1.2.3.4,3.4.5.6"
    70. 

  70.     assert_equal "3.4.5.6", request.remote_ip
    71. 

  71. 

  72.     request = stub_request "REMOTE_ADDR" => "1.2.3.4",
    73. 

  73.                            "HTTP_X_FORWARDED_FOR" => "3.4.5.6"
    74. 

  74.     assert_equal "3.4.5.6", request.remote_ip
    75. 

  75. 

  76.     request = stub_request "REMOTE_ADDR" => "127.0.0.1",
    77. 

  77.                            "HTTP_X_FORWARDED_FOR" => "3.4.5.6"
    78. 

  78.     assert_equal "3.4.5.6", request.remote_ip
    79. 

  79. 

  80.     request = stub_request "REMOTE_ADDR" => "127.0.0.1",
    81. 

  81.                            "HTTP_X_FORWARDED_FOR" => "172.31.4.4, 10.0.0.1"
    82. 

  82.     assert_equal "172.31.4.4", request.remote_ip
    83. 

  83. 

  84.     request = stub_request "HTTP_X_FORWARDED_FOR" => "3.4.5.6,unknown"
    85. 

  85.     assert_equal "3.4.5.6", request.remote_ip
    86. 

  86. 

  87.     request = stub_request "HTTP_X_FORWARDED_FOR" => "3.4.5.6,172.16.0.1"
    88. 

  88.     assert_equal "3.4.5.6", request.remote_ip
    89. 

  89. 

  90.     request = stub_request "HTTP_X_FORWARDED_FOR" => "3.4.5.6,192.168.0.1"
    91. 

  91.     assert_equal "3.4.5.6", request.remote_ip
    92. 

  92. 

  93.     request = stub_request "HTTP_X_FORWARDED_FOR" => "3.4.5.6,10.0.0.1"
    94. 

  94.     assert_equal "3.4.5.6", request.remote_ip
    95. 

  95. 

  96.     request = stub_request "HTTP_X_FORWARDED_FOR" => "172.31.4.4, 10.0.0.1"
    97. 

  97.     assert_equal "172.31.4.4", request.remote_ip
    98. 

  98. 

  99.     request = stub_request "HTTP_X_FORWARDED_FOR" => "3.4.5.6, 10.0.0.1, 10.0.0.1"
    100. 

  100.     assert_equal "3.4.5.6", request.remote_ip
    101. 

  101. 

  102.     request = stub_request "HTTP_X_FORWARDED_FOR" => "3.4.5.6,127.0.0.1"
    103. 

  103.     assert_equal "3.4.5.6", request.remote_ip
    104. 

  104. 

  105.     request = stub_request "HTTP_X_FORWARDED_FOR" => "3.4.5.6:1234,127.0.0.1"
    106. 

  106.     assert_equal "3.4.5.6", request.remote_ip
    107. 

  107. 

  108.     request = stub_request "HTTP_X_FORWARDED_FOR" => "unknown,192.168.0.1"
    109. 

  109.     assert_equal "192.168.0.1", request.remote_ip
    110. 

  110. 

  111.     request = stub_request "HTTP_X_FORWARDED_FOR" => "9.9.9.9, 3.4.5.6, 172.31.4.4, 10.0.0.1"
    112. 

  112.     assert_equal "3.4.5.6", request.remote_ip
    113. 

  113. 

  114.     request = stub_request "HTTP_X_FORWARDED_FOR" => "not_ip_address"
    115. 

  115.     assert_nil request.remote_ip
    116. 

  116. 

  117.     request = stub_request "REMOTE_ADDR" => "1.2.3.4"
    118. 

  118.     assert_equal "1.2.3.4", request.remote_ip
    119. 

  119.     request.remote_ip = "2.3.4.5"
    120. 

  120.     assert_equal "2.3.4.5", request.remote_ip
    121. 

  121.   end
    122. 

  122. 

  123.   test "remote ip spoof detection" do
    124. 

  124.     request = stub_request "HTTP_X_FORWARDED_FOR" => "1.1.1.1",
    125. 

  125.                            "HTTP_CLIENT_IP"       => "2.2.2.2"
    126. 

  126.     e = assert_raise(ActionDispatch::RemoteIp::IpSpoofAttackError) {
    127. 

  127.       request.remote_ip
    128. 

  128.     }
    129. 

  129.     assert_match(/IP spoofing attack/, e.message)
    130. 

  130.     assert_match(/HTTP_X_FORWARDED_FOR="1\.1\.1\.1"/, e.message)
    131. 

  131.     assert_match(/HTTP_CLIENT_IP="2\.2\.2\.2"/, e.message)
    132. 

  132.   end
    133. 

  133. 

  134.   test "remote ip with spoof detection disabled" do
    135. 

  135.     request = stub_request "HTTP_X_FORWARDED_FOR" => "1.1.1.1",
    136. 

  136.                            "HTTP_CLIENT_IP"       => "2.2.2.2",
    137. 

  137.                            :ip_spoofing_check => false
    138. 

  138.     assert_equal "1.1.1.1", request.remote_ip
    139. 

  139.   end
    140. 

  140. 

  141.   test "remote ip spoof protection ignores private addresses" do
    142. 

  142.     request = stub_request "HTTP_X_FORWARDED_FOR" => "172.17.19.51",
    143. 

  143.                            "HTTP_CLIENT_IP"       => "172.17.19.51",
    144. 

  144.                            "REMOTE_ADDR"          => "1.1.1.1",
    145. 

  145.                            "HTTP_X_BLUECOAT_VIA"  => "de462e07a2db325e"
    146. 

  146.     assert_equal "1.1.1.1", request.remote_ip
    147. 

  147.   end
    148. 

  148. 

  149.   test "remote ip v6" do
    150. 

  150.     request = stub_request "REMOTE_ADDR" => "2001:0db8:85a3:0000:0000:8a2e:0370:7334"
    151. 

  151.     assert_equal "2001:0db8:85a3:0000:0000:8a2e:0370:7334", request.remote_ip
    152. 

  152. 

  153.     request = stub_request "REMOTE_ADDR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329,2001:0db8:85a3:0000:0000:8a2e:0370:7334"
    154. 

  154.     assert_equal "2001:0db8:85a3:0000:0000:8a2e:0370:7334", request.remote_ip
    155. 

  155. 

  156.     request = stub_request "REMOTE_ADDR" => "2001:0db8:85a3:0000:0000:8a2e:0370:7334",
    157. 

  157.                            "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329"
    158. 

  158.     assert_equal "fe80:0000:0000:0000:0202:b3ff:fe1e:8329", request.remote_ip
    159. 

  159. 

  160.     request = stub_request "REMOTE_ADDR" => "::1",
    161. 

  161.                            "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329"
    162. 

  162.     assert_equal "fe80:0000:0000:0000:0202:b3ff:fe1e:8329", request.remote_ip
    163. 

  163. 

  164.     request = stub_request "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329,unknown"
    165. 

  165.     assert_equal "fe80:0000:0000:0000:0202:b3ff:fe1e:8329", request.remote_ip
    166. 

  166. 

  167.     request = stub_request "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329,::1"
    168. 

  168.     assert_equal "fe80:0000:0000:0000:0202:b3ff:fe1e:8329", request.remote_ip
    169. 

  169. 

  170.     request = stub_request "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329, ::1, ::1"
    171. 

  171.     assert_equal "fe80:0000:0000:0000:0202:b3ff:fe1e:8329", request.remote_ip
    172. 

  172. 

  173.     request = stub_request "HTTP_X_FORWARDED_FOR" => "unknown,::1"
    174. 

  174.     assert_equal "::1", request.remote_ip
    175. 

  175. 

  176.     request = stub_request "HTTP_X_FORWARDED_FOR" => "2001:0db8:85a3:0000:0000:8a2e:0370:7334, fe80:0000:0000:0000:0202:b3ff:fe1e:8329, ::1, fc00::, fc01::, fdff"
    177. 

  177.     assert_equal "fe80:0000:0000:0000:0202:b3ff:fe1e:8329", request.remote_ip
    178. 

  178. 

  179.     request = stub_request "HTTP_X_FORWARDED_FOR" => "FE00::, FDFF::"
    180. 

  180.     assert_equal "FE00::", request.remote_ip
    181. 

  181. 

  182.     request = stub_request "HTTP_X_FORWARDED_FOR" => "not_ip_address"
    183. 

  183.     assert_nil request.remote_ip
    184. 

  184.   end
    185. 

  185. 

  186.   test "remote ip v6 spoof detection" do
    187. 

  187.     request = stub_request "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329",
    188. 

  188.                            "HTTP_CLIENT_IP"       => "2001:0db8:85a3:0000:0000:8a2e:0370:7334"
    189. 

  189.     e = assert_raise(ActionDispatch::RemoteIp::IpSpoofAttackError) {
    190. 

  190.       request.remote_ip
    191. 

  191.     }
    192. 

  192.     assert_match(/IP spoofing attack/, e.message)
    193. 

  193.     assert_match(/HTTP_X_FORWARDED_FOR="fe80:0000:0000:0000:0202:b3ff:fe1e:8329"/, e.message)
    194. 

  194.     assert_match(/HTTP_CLIENT_IP="2001:0db8:85a3:0000:0000:8a2e:0370:7334"/, e.message)
    195. 

  195.   end
    196. 

  196. 

  197.   test "remote ip v6 spoof detection disabled" do
    198. 

  198.     request = stub_request "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329",
    199. 

  199.                            "HTTP_CLIENT_IP"       => "2001:0db8:85a3:0000:0000:8a2e:0370:7334",
    200. 

  200.                            :ip_spoofing_check     => false
    201. 

  201.     assert_equal "fe80:0000:0000:0000:0202:b3ff:fe1e:8329", request.remote_ip
    202. 

  202.   end
    203. 

  203. 

  204.   test "remote ip with user specified trusted proxies String" do
    205. 

  205.     @trusted_proxies = "67.205.106.73"
    206. 

  206. 

  207.     request = stub_request "REMOTE_ADDR" => "3.4.5.6",
    208. 

  208.                            "HTTP_X_FORWARDED_FOR" => "67.205.106.73"
    209. 

  209.     assert_equal "3.4.5.6", request.remote_ip
    210. 

  210. 

  211.     request = stub_request "REMOTE_ADDR" => "172.16.0.1,67.205.106.73",
    212. 

  212.                            "HTTP_X_FORWARDED_FOR" => "67.205.106.73"
    213. 

  213.     assert_equal "67.205.106.73", request.remote_ip
    214. 

  214. 

  215.     request = stub_request "REMOTE_ADDR" => "67.205.106.73,3.4.5.6",
    216. 

  216.                            "HTTP_X_FORWARDED_FOR" => "67.205.106.73"
    217. 

  217.     assert_equal "3.4.5.6", request.remote_ip
    218. 

  218. 

  219.     request = stub_request "HTTP_X_FORWARDED_FOR" => "67.205.106.73,unknown"
    220. 

  220.     assert_equal "67.205.106.73", request.remote_ip # change
    221. 

  221. 

  222.     request = stub_request "HTTP_X_FORWARDED_FOR" => "9.9.9.9, 3.4.5.6, 10.0.0.1, 67.205.106.73"
    223. 

  223.     assert_equal "3.4.5.6", request.remote_ip
    224. 

  224.   end
    225. 

  225. 

  226.   test "remote ip v6 with user specified trusted proxies String" do
    227. 

  227.     @trusted_proxies = "fe80:0000:0000:0000:0202:b3ff:fe1e:8329"
    228. 

  228. 

  229.     request = stub_request "REMOTE_ADDR" => "2001:0db8:85a3:0000:0000:8a2e:0370:7334",
    230. 

  230.                            "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329"
    231. 

  231.     assert_equal "2001:0db8:85a3:0000:0000:8a2e:0370:7334", request.remote_ip
    232. 

  232. 

  233.     request = stub_request "REMOTE_ADDR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329,2001:0db8:85a3:0000:0000:8a2e:0370:7334",
    234. 

  234.                            "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329"
    235. 

  235.     assert_equal "2001:0db8:85a3:0000:0000:8a2e:0370:7334", request.remote_ip
    236. 

  236. 

  237.     request = stub_request "REMOTE_ADDR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329,::1",
    238. 

  238.                            "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329"
    239. 

  239.     assert_equal "fe80:0000:0000:0000:0202:b3ff:fe1e:8329", request.remote_ip
    240. 

  240. 

  241.     request = stub_request "HTTP_X_FORWARDED_FOR" => "unknown,fe80:0000:0000:0000:0202:b3ff:fe1e:8329"
    242. 

  242.     assert_equal "fe80:0000:0000:0000:0202:b3ff:fe1e:8329", request.remote_ip
    243. 

  243. 

  244.     request = stub_request "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329,2001:0db8:85a3:0000:0000:8a2e:0370:7334"
    245. 

  245.     assert_equal "2001:0db8:85a3:0000:0000:8a2e:0370:7334", request.remote_ip
    246. 

  246.   end
    247. 

  247. 

  248.   test "remote ip with user specified trusted proxies Regexp" do
    249. 

  249.     @trusted_proxies = /^67\.205\.106\.73$/i
    250. 

  250. 

  251.     request = stub_request "REMOTE_ADDR" => "67.205.106.73",
    252. 

  252.                            "HTTP_X_FORWARDED_FOR" => "3.4.5.6"
    253. 

  253.     assert_equal "3.4.5.6", request.remote_ip
    254. 

  254. 

  255.     request = stub_request "HTTP_X_FORWARDED_FOR" => "10.0.0.1, 9.9.9.9, 3.4.5.6, 67.205.106.73"
    256. 

  256.     assert_equal "3.4.5.6", request.remote_ip
    257. 

  257.   end
    258. 

  258. 

  259.   test "remote ip v6 with user specified trusted proxies Regexp" do
    260. 

  260.     @trusted_proxies = /^fe80:0000:0000:0000:0202:b3ff:fe1e:8329$/i
    261. 

  261. 

  262.     request = stub_request "REMOTE_ADDR" => "2001:0db8:85a3:0000:0000:8a2e:0370:7334",
    263. 

  263.                            "HTTP_X_FORWARDED_FOR" => "fe80:0000:0000:0000:0202:b3ff:fe1e:8329"
    264. 

  264.     assert_equal "2001:0db8:85a3:0000:0000:8a2e:0370:7334", request.remote_ip
    265. 

  265. 

  266.     request = stub_request "HTTP_X_FORWARDED_FOR" => "2001:0db8:85a3:0000:0000:8a2e:0370:7334, fe80:0000:0000:0000:0202:b3ff:fe1e:8329"
    267. 

  267.     assert_equal "2001:0db8:85a3:0000:0000:8a2e:0370:7334", request.remote_ip
    268. 

  268.   end
    269. 

  269. 

  270.   test "remote ip middleware not present still returns an IP" do
    271. 

  271.     request = stub_request("REMOTE_ADDR" => "127.0.0.1")
    272. 

  272.     assert_equal "127.0.0.1", request.remote_ip
    273. 

  273.   end
    274. 

  274. end
    275. 

  275. 

  276. class RequestDomain < BaseRequestTest
    277. 

  277.   test "domains" do
    278. 

  278.     request = stub_request "HTTP_HOST" => "192.168.1.200"
    279. 

  279.     assert_nil request.domain
    280. 

  280. 

  281.     request = stub_request "HTTP_HOST" => "foo.192.168.1.200"
    282. 

  282.     assert_nil request.domain
    283. 

  283. 

  284.     request = stub_request "HTTP_HOST" => "192.168.1.200.com"
    285. 

  285.     assert_equal "200.com", request.domain
    286. 

  286. 

  287.     request = stub_request "HTTP_HOST" => "www.rubyonrails.org"
    288. 

  288.     assert_equal "rubyonrails.org", request.domain
    289. 

  289. 

  290.     request = stub_request "HTTP_HOST" => "www.rubyonrails.co.uk"
    291. 

  291.     assert_equal "rubyonrails.co.uk", request.domain(2)
    292. 

  292. 

  293.     request = stub_request "HTTP_HOST" => "www.rubyonrails.co.uk", :tld_length => 2
    294. 

  294.     assert_equal "rubyonrails.co.uk", request.domain
    295. 

  295.   end
    296. 

  296. 

  297.   test "subdomains" do
    298. 

  298.     request = stub_request "HTTP_HOST" => "foobar.foobar.com"
    299. 

  299.     assert_equal %w( foobar ), request.subdomains
    300. 

  300.     assert_equal "foobar", request.subdomain
    301. 

  301. 

  302.     request = stub_request "HTTP_HOST" => "192.168.1.200"
    303. 

  303.     assert_equal [], request.subdomains
    304. 

  304.     assert_equal "", request.subdomain
    305. 

  305. 

  306.     request = stub_request "HTTP_HOST" => "foo.192.168.1.200"
    307. 

  307.     assert_equal [], request.subdomains
    308. 

  308.     assert_equal "", request.subdomain
    309. 

  309. 

  310.     request = stub_request "HTTP_HOST" => "192.168.1.200.com"
    311. 

  311.     assert_equal %w( 192 168 1 ), request.subdomains
    312. 

  312.     assert_equal "192.168.1", request.subdomain
    313. 

  313. 

  314.     request = stub_request "HTTP_HOST" => nil
    315. 

  315.     assert_equal [], request.subdomains
    316. 

  316.     assert_equal "", request.subdomain
    317. 

  317. 

  318.     request = stub_request "HTTP_HOST" => "www.rubyonrails.org"
    319. 

  319.     assert_equal %w( www ), request.subdomains
    320. 

  320.     assert_equal "www", request.subdomain
    321. 

  321. 

  322.     request = stub_request "HTTP_HOST" => "www.rubyonrails.co.uk"
    323. 

  323.     assert_equal %w( www ), request.subdomains(2)
    324. 

  324.     assert_equal "www", request.subdomain(2)
    325. 

  325. 

  326.     request = stub_request "HTTP_HOST" => "dev.www.rubyonrails.co.uk"
    327. 

  327.     assert_equal %w( dev www ), request.subdomains(2)
    328. 

  328.     assert_equal "dev.www", request.subdomain(2)
    329. 

  329. 

  330.     request = stub_request "HTTP_HOST" => "dev.www.rubyonrails.co.uk", :tld_length => 2
    331. 

  331.     assert_equal %w( dev www ), request.subdomains
    332. 

  332.     assert_equal "dev.www", request.subdomain
    333. 

  333.   end
    334. 

  334. end
    335. 

  335. 

  336. class RequestPort < BaseRequestTest
    337. 

  337.   test "standard_port" do
    338. 

  338.     request = stub_request
    339. 

  339.     assert_equal 80, request.standard_port
    340. 

  340. 

  341.     request = stub_request "HTTPS" => "on"
    342. 

  342.     assert_equal 443, request.standard_port
    343. 

  343.   end
    344. 

  344. 

  345.   test "standard_port?" do
    346. 

  346.     request = stub_request
    347. 

  347.     assert_not_predicate request, :ssl?
    348. 

  348.     assert_predicate request, :standard_port?
    349. 

  349. 

  350.     request = stub_request "HTTPS" => "on"
    351. 

  351.     assert_predicate request, :ssl?
    352. 

  352.     assert_predicate request, :standard_port?
    353. 

  353. 

  354.     request = stub_request "HTTP_HOST" => "www.example.org:8080"
    355. 

  355.     assert_not_predicate request, :ssl?
    356. 

  356.     assert_not_predicate request, :standard_port?
    357. 

  357. 

  358.     request = stub_request "HTTP_HOST" => "www.example.org:8443", "HTTPS" => "on"
    359. 

  359.     assert_predicate request, :ssl?
    360. 

  360.     assert_not_predicate request, :standard_port?
    361. 

  361.   end
    362. 

  362. 

  363.   test "optional port" do
    364. 

  364.     request = stub_request "HTTP_HOST" => "www.example.org:80"
    365. 

  365.     assert_nil request.optional_port
    366. 

  366. 

  367.     request = stub_request "HTTP_HOST" => "www.example.org:8080"
    368. 

  368.     assert_equal 8080, request.optional_port
    369. 

  369.   end
    370. 

  370. 

  371.   test "port string" do
    372. 

  372.     request = stub_request "HTTP_HOST" => "www.example.org:80"
    373. 

  373.     assert_equal "", request.port_string
    374. 

  374. 

  375.     request = stub_request "HTTP_HOST" => "www.example.org:8080"
    376. 

  376.     assert_equal ":8080", request.port_string
    377. 

  377.   end
    378. 

  378. 

  379.   test "server port" do
    380. 

  380.     request = stub_request "SERVER_PORT" => "8080"
    381. 

  381.     assert_equal 8080, request.server_port
    382. 

  382. 

  383.     request = stub_request "SERVER_PORT" => "80"
    384. 

  384.     assert_equal 80, request.server_port
    385. 

  385. 

  386.     request = stub_request "SERVER_PORT" => ""
    387. 

  387.     assert_equal 0, request.server_port
    388. 

  388.   end
    389. 

  389. end
    390. 

  390. 

  391. class RequestPath < BaseRequestTest
    392. 

  392.   test "full path" do
    393. 

  393.     request = stub_request "SCRIPT_NAME" => "", "PATH_INFO" => "/path/of/some/uri", "QUERY_STRING" => "mapped=1"
    394. 

  394.     assert_equal "/path/of/some/uri?mapped=1", request.fullpath
    395. 

  395.     assert_equal "/path/of/some/uri",          request.path_info
    396. 

  396. 

  397.     request = stub_request "SCRIPT_NAME" => "", "PATH_INFO" => "/path/of/some/uri"
    398. 

  398.     assert_equal "/path/of/some/uri", request.fullpath
    399. 

  399.     assert_equal "/path/of/some/uri", request.path_info
    400. 

  400. 

  401.     request = stub_request "SCRIPT_NAME" => "", "PATH_INFO" => "/"
    402. 

  402.     assert_equal "/", request.fullpath
    403. 

  403.     assert_equal "/", request.path_info
    404. 

  404. 

  405.     request = stub_request "SCRIPT_NAME" => "", "PATH_INFO" => "/", "QUERY_STRING" => "m=b"
    406. 

  406.     assert_equal "/?m=b", request.fullpath
    407. 

  407.     assert_equal "/",     request.path_info
    408. 

  408. 

  409.     request = stub_request "SCRIPT_NAME" => "/hieraki", "PATH_INFO" => "/"
    410. 

  410.     assert_equal "/hieraki/", request.fullpath
    411. 

  411.     assert_equal "/",         request.path_info
    412. 

  412. 

  413.     request = stub_request "SCRIPT_NAME" => "/collaboration/hieraki", "PATH_INFO" => "/books/edit/2"
    414. 

  414.     assert_equal "/collaboration/hieraki/books/edit/2", request.fullpath
    415. 

  415.     assert_equal "/books/edit/2",                       request.path_info
    416. 

  416. 

  417.     request = stub_request "SCRIPT_NAME" => "/path", "PATH_INFO" => "/of/some/uri", "QUERY_STRING" => "mapped=1"
    418. 

  418.     assert_equal "/path/of/some/uri?mapped=1", request.fullpath
    419. 

  419.     assert_equal "/of/some/uri",               request.path_info
    420. 

  420.   end
    421. 

  421. 

  422.   test "original_fullpath returns ORIGINAL_FULLPATH" do
    423. 

  423.     request = stub_request("ORIGINAL_FULLPATH" => "/foo?bar")
    424. 

  424. 

  425.     path = request.original_fullpath
    426. 

  426.     assert_equal "/foo?bar", path
    427. 

  427.   end
    428. 

  428. 

  429.   test "original_url returns URL built using ORIGINAL_FULLPATH" do
    430. 

  430.     request = stub_request("ORIGINAL_FULLPATH" => "/foo?bar",
    431. 

  431.                            "HTTP_HOST"         => "example.org",
    432. 

  432.                            "rack.url_scheme"   => "http")
    433. 

  433. 

  434.     url = request.original_url
    435. 

  435.     assert_equal "http://example.org/foo?bar", url
    436. 

  436.   end
    437. 

  437. 

  438.   test "original_fullpath returns fullpath if ORIGINAL_FULLPATH is not present" do
    439. 

  439.     request = stub_request("PATH_INFO"    => "/foo",
    440. 

  440.                            "QUERY_STRING" => "bar")
    441. 

  441. 

  442.     path = request.original_fullpath
    443. 

  443.     assert_equal "/foo?bar", path
    444. 

  444.   end
    445. 

  445. end
    446. 

  446. 

  447. class RequestHost < BaseRequestTest
    448. 

  448.   test "host without specifying port" do
    449. 

  449.     request = stub_request "HTTP_HOST" => "rubyonrails.org"
    450. 

  450.     assert_equal "rubyonrails.org", request.host_with_port
    451. 

  451.   end
    452. 

  452. 

  453.   test "host with default port" do
    454. 

  454.     request = stub_request "HTTP_HOST" => "rubyonrails.org:80"
    455. 

  455.     assert_equal "rubyonrails.org", request.host_with_port
    456. 

  456.   end
    457. 

  457. 

  458.   test "host with non default port" do
    459. 

  459.     request = stub_request "HTTP_HOST" => "rubyonrails.org:81"
    460. 

  460.     assert_equal "rubyonrails.org:81", request.host_with_port
    461. 

  461.   end
    462. 

  462. 

  463.   test "raw without specifying port" do
    464. 

  464.     request = stub_request "HTTP_HOST" => "rubyonrails.org"
    465. 

  465.     assert_equal "rubyonrails.org", request.raw_host_with_port
    466. 

  466.   end
    467. 

  467. 

  468.   test "raw host with default port" do
    469. 

  469.     request = stub_request "HTTP_HOST" => "rubyonrails.org:80"
    470. 

  470.     assert_equal "rubyonrails.org:80", request.raw_host_with_port
    471. 

  471.   end
    472. 

  472. 

  473.   test "raw host with non default port" do
    474. 

  474.     request = stub_request "HTTP_HOST" => "rubyonrails.org:81"
    475. 

  475.     assert_equal "rubyonrails.org:81", request.raw_host_with_port
    476. 

  476.   end
    477. 

  477. 

  478.   test "proxy request" do
    479. 

  479.     request = stub_request "HTTP_HOST" => "glu.ttono.us:80"
    480. 

  480.     assert_equal "glu.ttono.us", request.host_with_port
    481. 

  481.   end
    482. 

  482. 

  483.   test "http host" do
    484. 

  484.     request = stub_request "HTTP_HOST" => "rubyonrails.org:8080"
    485. 

  485.     assert_equal "rubyonrails.org", request.host
    486. 

  486.     assert_equal "rubyonrails.org:8080", request.host_with_port
    487. 

  487. 

  488.     request = stub_request "HTTP_X_FORWARDED_HOST" => "www.firsthost.org, www.secondhost.org"
    489. 

  489.     assert_equal "www.secondhost.org", request.host
    490. 

  490. 

  491.     request = stub_request "HTTP_X_FORWARDED_HOST" => "", "HTTP_HOST" => "rubyonrails.org"
    492. 

  492.     assert_equal "rubyonrails.org", request.host
    493. 

  493.   end
    494. 

  494. 

  495.   test "http host with default port overrides server port" do
    496. 

  496.     request = stub_request "HTTP_HOST" => "rubyonrails.org"
    497. 

  497.     assert_equal "rubyonrails.org", request.host_with_port
    498. 

  498.   end
    499. 

  499. 

  500.   test "host with port if http standard port is specified" do
    501. 

  501.     request = stub_request "HTTP_X_FORWARDED_HOST" => "glu.ttono.us:80"
    502. 

  502.     assert_equal "glu.ttono.us", request.host_with_port
    503. 

  503.   end
    504. 

  504. 

  505.   test "host with port if https standard port is specified" do
    506. 

  506.     request = stub_request(
    507. 

  507.       "HTTP_X_FORWARDED_PROTO" => "https",
    508. 

  508.       "HTTP_X_FORWARDED_HOST" => "glu.ttono.us:443"
    509. 

  509.     )
    510. 

  510.     assert_equal "glu.ttono.us", request.host_with_port
    511. 

  511.   end
    512. 

  512. 

  513.   test "host if ipv6 reference" do
    514. 

  514.     request = stub_request "HTTP_HOST" => "[2001:1234:5678:9abc:def0::dead:beef]"
    515. 

  515.     assert_equal "[2001:1234:5678:9abc:def0::dead:beef]", request.host
    516. 

  516.   end
    517. 

  517. 

  518.   test "host if ipv6 reference with port" do
    519. 

  519.     request = stub_request "HTTP_HOST" => "[2001:1234:5678:9abc:def0::dead:beef]:8008"
    520. 

  520.     assert_equal "[2001:1234:5678:9abc:def0::dead:beef]", request.host
    521. 

  521.   end
    522. 

  522. end
    523. 

  523. 

  524. class RequestCGI < BaseRequestTest
    525. 

  525.   test "CGI environment variables" do
    526. 

  526.     request = stub_request(
    527. 

  527.       "AUTH_TYPE" => "Basic",
    528. 

  528.       "GATEWAY_INTERFACE" => "CGI/1.1",
    529. 

  529.       "HTTP_ACCEPT" => "*/*",
    530. 

  530.       "HTTP_ACCEPT_CHARSET" => "UTF-8",
    531. 

  531.       "HTTP_ACCEPT_ENCODING" => "gzip, deflate",
    532. 

  532.       "HTTP_ACCEPT_LANGUAGE" => "en",
    533. 

  533.       "HTTP_CACHE_CONTROL" => "no-cache, max-age=0",
    534. 

  534.       "HTTP_FROM" => "googlebot",
    535. 

  535.       "HTTP_HOST" => "glu.ttono.us:8007",
    536. 

  536.       "HTTP_NEGOTIATE" => "trans",
    537. 

  537.       "HTTP_PRAGMA" => "no-cache",
    538. 

  538.       "HTTP_REFERER" => "http://www.google.com/search?q=glu.ttono.us",
    539. 

  539.       "HTTP_USER_AGENT" => "Mozilla/5.0 (Macintosh; U; PPC Mac OS X; en)",
    540. 

  540.       "PATH_INFO" => "/homepage/",
    541. 

  541.       "PATH_TRANSLATED" => "/home/kevinc/sites/typo/public/homepage/",
    542. 

  542.       "QUERY_STRING" => "",
    543. 

  543.       "REMOTE_ADDR" => "207.7.108.53",
    544. 

  544.       "REMOTE_HOST" => "google.com",
    545. 

  545.       "REMOTE_IDENT" => "kevin",
    546. 

  546.       "REMOTE_USER" => "kevin",
    547. 

  547.       "REQUEST_METHOD" => "GET",
    548. 

  548.       "SCRIPT_NAME" => "/dispatch.fcgi",
    549. 

  549.       "SERVER_NAME" => "glu.ttono.us",
    550. 

  550.       "SERVER_PORT" => "8007",
    551. 

  551.       "SERVER_PROTOCOL" => "HTTP/1.1",
    552. 

  552.       "SERVER_SOFTWARE" => "lighttpd/1.4.5",
    553. 

  553.     )
    554. 

  554. 

  555.     assert_equal "Basic", request.auth_type
    556. 

  556.     assert_equal 0, request.content_length
    557. 

  557.     assert_nil request.content_mime_type
    558. 

  558.     assert_equal "CGI/1.1", request.gateway_interface
    559. 

  559.     assert_equal "*/*", request.accept
    560. 

  560.     assert_equal "UTF-8", request.accept_charset
    561. 

  561.     assert_equal "gzip, deflate", request.accept_encoding
    562. 

  562.     assert_equal "en", request.accept_language
    563. 

  563.     assert_equal "no-cache, max-age=0", request.cache_control
    564. 

  564.     assert_equal "googlebot", request.from
    565. 

  565.     assert_equal "glu.ttono.us", request.host
    566. 

  566.     assert_equal "trans", request.negotiate
    567. 

  567.     assert_equal "no-cache", request.pragma
    568. 

  568.     assert_equal "http://www.google.com/search?q=glu.ttono.us", request.referer
    569. 

  569.     assert_equal "Mozilla/5.0 (Macintosh; U; PPC Mac OS X; en)", request.user_agent
    570. 

  570.     assert_equal "/homepage/", request.path_info
    571. 

  571.     assert_equal "/home/kevinc/sites/typo/public/homepage/", request.path_translated
    572. 

  572.     assert_equal "", request.query_string
    573. 

  573.     assert_equal "207.7.108.53", request.remote_addr
    574. 

  574.     assert_equal "google.com", request.remote_host
    575. 

  575.     assert_equal "kevin", request.remote_ident
    576. 

  576.     assert_equal "kevin", request.remote_user
    577. 

  577.     assert_equal "GET", request.request_method
    578. 

  578.     assert_equal "/dispatch.fcgi", request.script_name
    579. 

  579.     assert_equal "glu.ttono.us", request.server_name
    580. 

  580.     assert_equal 8007, request.server_port
    581. 

  581.     assert_equal "HTTP/1.1", request.server_protocol
    582. 

  582.     assert_equal "lighttpd", request.server_software
    583. 

  583.   end
    584. 

  584. end
    585. 

  585. 

  586. class LocalhostTest < BaseRequestTest
    587. 

  587.   test "IPs that match localhost" do
    588. 

  588.     request = stub_request("REMOTE_IP" => "127.1.1.1", "REMOTE_ADDR" => "127.1.1.1")
    589. 

  589.     assert_predicate request, :local?
    590. 

  590.   end
    591. 

  591. end
    592. 

  592. 

  593. class RequestCookie < BaseRequestTest
    594. 

  594.   test "cookie syntax resilience" do
    595. 

  595.     request = stub_request("HTTP_COOKIE" => "_session_id=c84ace84796670c052c6ceb2451fb0f2; is_admin=yes")
    596. 

  596.     assert_equal "c84ace84796670c052c6ceb2451fb0f2", request.cookies["_session_id"], request.cookies.inspect
    597. 

  597.     assert_equal "yes", request.cookies["is_admin"], request.cookies.inspect
    598. 

  598.   end
    599. 

  599. end
    600. 

  600. 

  601. class RequestParamsParsing < BaseRequestTest
    602. 

  602.   test "doesnt break when content type has charset" do
    603. 

  603.     request = stub_request(
    604. 

  604.       "REQUEST_METHOD" => "POST",
    605. 

  605.       "CONTENT_LENGTH" => "flamenco=love".length,
    606. 

  606.       "CONTENT_TYPE" => "application/x-www-form-urlencoded; charset=utf-8",
    607. 

  607.       "rack.input" => StringIO.new("flamenco=love")
    608. 

  608.     )
    609. 

  609. 

  610.     assert_equal({ "flamenco" => "love" }, request.request_parameters)
    611. 

  611.   end
    612. 

  612. 

  613.   test "doesnt interpret request uri as query string when missing" do
    614. 

  614.     request = stub_request("REQUEST_URI" => "foo")
    615. 

  615.     assert_equal({}, request.query_parameters)
    616. 

  616.   end
    617. 

  617. end
    618. 

  618. 

  619. class RequestRewind < BaseRequestTest
    620. 

  620.   test "body should be rewound" do
    621. 

  621.     data = "rewind"
    622. 

  622.     env = {
    623. 

  623.       "rack.input" => StringIO.new(data),
    624. 

  624.       "CONTENT_LENGTH" => data.length,
    625. 

  625.       "CONTENT_TYPE" => "application/x-www-form-urlencoded; charset=utf-8"
    626. 

  626.     }
    627. 

  627. 

  628.     # Read the request body by parsing params.
    629. 

  629.     request = stub_request(env)
    630. 

  630.     request.request_parameters
    631. 

  631. 

  632.     # Should have rewound the body.
    633. 

  633.     assert_equal 0, request.body.pos
    634. 

  634.   end
    635. 

  635. 

  636.   test "raw_post rewinds rack.input if RAW_POST_DATA is nil" do
    637. 

  637.     request = stub_request(
    638. 

  638.       "rack.input" => StringIO.new("raw"),
    639. 

  639.       "CONTENT_LENGTH" => 3
    640. 

  640.     )
    641. 

  641.     assert_equal "raw", request.raw_post
    642. 

  642.     assert_equal "raw", request.env["rack.input"].read
    643. 

  643.   end
    644. 

  644. end
    645. 

  645. 

  646. class RequestProtocol < BaseRequestTest
    647. 

  647.   test "server software" do
    648. 

  648.     assert_equal "lighttpd", stub_request("SERVER_SOFTWARE" => "lighttpd/1.4.5").server_software
    649. 

  649.     assert_equal "apache", stub_request("SERVER_SOFTWARE" => "Apache3.422").server_software
    650. 

  650.   end
    651. 

  651. 

  652.   test "xml http request" do
    653. 

  653.     request = stub_request
    654. 

  654. 

  655.     assert_not_predicate request, :xml_http_request?
    656. 

  656.     assert_not_predicate request, :xhr?
    657. 

  657. 

  658.     request = stub_request "HTTP_X_REQUESTED_WITH" => "DefinitelyNotAjax1.0"
    659. 

  659.     assert_not_predicate request, :xml_http_request?
    660. 

  660.     assert_not_predicate request, :xhr?
    661. 

  661. 

  662.     request = stub_request "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest"
    663. 

  663.     assert_predicate request, :xml_http_request?
    664. 

  664.     assert_predicate request, :xhr?
    665. 

  665.   end
    666. 

  666. 

  667.   test "reports ssl" do
    668. 

  668.     assert_not_predicate stub_request, :ssl?
    669. 

  669.     assert_predicate stub_request("HTTPS" => "on"), :ssl?
    670. 

  670.   end
    671. 

  671. 

  672.   test "reports ssl when proxied via lighttpd" do
    673. 

  673.     assert_predicate stub_request("HTTP_X_FORWARDED_PROTO" => "https"), :ssl?
    674. 

  674.   end
    675. 

  675. 

  676.   test "scheme returns https when proxied" do
    677. 

  677.     request = stub_request "rack.url_scheme" => "http"
    678. 

  678.     assert_not_predicate request, :ssl?
    679. 

  679.     assert_equal "http", request.scheme
    680. 

  680. 

  681.     request = stub_request(
    682. 

  682.       "rack.url_scheme" => "http",
    683. 

  683.       "HTTP_X_FORWARDED_PROTO" => "https"
    684. 

  684.     )
    685. 

  685.     assert_predicate request, :ssl?
    686. 

  686.     assert_equal "https", request.scheme
    687. 

  687.   end
    688. 

  688. end
    689. 

  689. 

  690. class RequestMethod < BaseRequestTest
    691. 

  691.   test "method returns environment's request method when it has not been
    692. 

  692.     overridden by middleware".squish do
    693. 

  693.     ActionDispatch::Request::HTTP_METHODS.each do |method|
    694. 

  694.       request = stub_request("REQUEST_METHOD" => method)
    695. 

  695. 

  696.       assert_equal method, request.method
    697. 

  697.       assert_equal method.underscore.to_sym, request.method_symbol
    698. 

  698.     end
    699. 

  699.   end
    700. 

  700. 

  701.   test "allow request method hacking" do
    702. 

  702.     request = stub_request("REQUEST_METHOD" => "POST")
    703. 

  703. 

  704.     assert_equal "POST", request.request_method
    705. 

  705.     assert_equal "POST", request.env["REQUEST_METHOD"]
    706. 

  706. 

  707.     request.request_method = "GET"
    708. 

  708. 

  709.     assert_equal "GET", request.request_method
    710. 

  710.     assert_equal "GET", request.env["REQUEST_METHOD"]
    711. 

  711.     assert_predicate request, :get?
    712. 

  712.   end
    713. 

  713. 

  714.   test "invalid http method raises exception" do
    715. 

  715.     assert_raise(ActionController::UnknownHttpMethod) do
    716. 

  716.       stub_request("REQUEST_METHOD" => "RANDOM_METHOD").request_method
    717. 

  717.     end
    718. 

  718.   end
    719. 

  719. 

  720.   test "method returns original value of environment request method on POST" do
    721. 

  721.     request = stub_request("rack.methodoverride.original_method" => "POST")
    722. 

  722.     assert_equal "POST", request.method
    723. 

  723.   end
    724. 

  724. 

  725.   test "method raises exception on invalid HTTP method" do
    726. 

  726.     assert_raise(ActionController::UnknownHttpMethod) do
    727. 

  727.       stub_request("rack.methodoverride.original_method" => "_RANDOM_METHOD").method
    728. 

  728.     end
    729. 

  729. 

  730.     assert_raise(ActionController::UnknownHttpMethod) do
    731. 

  731.       stub_request("REQUEST_METHOD" => "_RANDOM_METHOD").method
    732. 

  732.     end
    733. 

  733.   end
    734. 

  734. 

  735.   test "exception on invalid HTTP method unaffected by I18n settings" do
    736. 

  736.     old_locales = I18n.available_locales
    737. 

  737.     old_enforce = I18n.config.enforce_available_locales
    738. 

  738. 

  739.     begin
    740. 

  740.       I18n.available_locales = [:nl]
    741. 

  741.       I18n.config.enforce_available_locales = true
    742. 

  742.       assert_raise(ActionController::UnknownHttpMethod) do
    743. 

  743.         stub_request("REQUEST_METHOD" => "_RANDOM_METHOD").method
    744. 

  744.       end
    745. 

  745.     ensure
    746. 

  746.       I18n.available_locales = old_locales
    747. 

  747.       I18n.config.enforce_available_locales = old_enforce
    748. 

  748.     end
    749. 

  749.   end
    750. 

  750. 

  751.   test "post masquerading as patch" do
    752. 

  752.     request = stub_request(
    753. 

  753.       "REQUEST_METHOD" => "PATCH",
    754. 

  754.       "rack.methodoverride.original_method" => "POST"
    755. 

  755.     )
    756. 

  756. 

  757.     assert_equal "POST", request.method
    758. 

  758.     assert_equal "PATCH",  request.request_method
    759. 

  759.     assert_predicate request, :patch?
    760. 

  760.   end
    761. 

  761. 

  762.   test "post masquerading as put" do
    763. 

  763.     request = stub_request(
    764. 

  764.       "REQUEST_METHOD" => "PUT",
    765. 

  765.       "rack.methodoverride.original_method" => "POST"
    766. 

  766.     )
    767. 

  767.     assert_equal "POST", request.method
    768. 

  768.     assert_equal "PUT",  request.request_method
    769. 

  769.     assert_predicate request, :put?
    770. 

  770.   end
    771. 

  771. 

  772.   test "post uneffected by local inflections" do
    773. 

  773.     existing_acronyms = ActiveSupport::Inflector.inflections.acronyms.dup
    774. 

  774.     begin
    775. 

  775.       ActiveSupport::Inflector.inflections do |inflect|
    776. 

  776.         inflect.acronym "POS"
    777. 

  777.       end
    778. 

  778.       assert_equal "pos_t", "POST".underscore
    779. 

  779.       request = stub_request "REQUEST_METHOD" => "POST"
    780. 

  780.       assert_equal :post, ActionDispatch::Request::HTTP_METHOD_LOOKUP["POST"]
    781. 

  781.       assert_equal :post, request.method_symbol
    782. 

  782.       assert_predicate request, :post?
    783. 

  783.     ensure
    784. 

  784.       # Reset original acronym set
    785. 

  785.       ActiveSupport::Inflector.inflections do |inflect|
    786. 

  786.         inflect.send(:instance_variable_set, "@acronyms", existing_acronyms)
    787. 

  787.         inflect.send(:define_acronym_regex_patterns)
    788. 

  788.       end
    789. 

  789.     end
    790. 

  790.   end
    791. 

  791. end
    792. 

  792. 

  793. class RequestFormat < BaseRequestTest
    794. 

  794.   test "xml format" do
    795. 

  795.     request = stub_request "QUERY_STRING" => "format=xml"
    796. 

  796. 

  797.     assert_equal Mime[:xml], request.format
    798. 

  798.   end
    799. 

  799. 

  800.   test "xhtml format" do
    801. 

  801.     request = stub_request "QUERY_STRING" => "format=xhtml"
    802. 

  802. 

  803.     assert_equal Mime[:html], request.format
    804. 

  804.   end
    805. 

  805. 

  806.   test "txt format" do
    807. 

  807.     request = stub_request "QUERY_STRING" => "format=txt"
    808. 

  808. 

  809.     assert_equal Mime[:text], request.format
    810. 

  810.   end
    811. 

  811. 

  812.   test "XMLHttpRequest" do
    813. 

  813.     request = stub_request(
    814. 

  814.       "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest",
    815. 

  815.       "HTTP_ACCEPT" => [Mime[:js], Mime[:html], Mime[:xml], "text/xml", "*/*"].join(","),
    816. 

  816.       "QUERY_STRING" => ""
    817. 

  817.     )
    818. 

  818. 

  819.     assert_predicate request, :xhr?
    820. 

  820.     assert_equal Mime[:js], request.format
    821. 

  821.   end
    822. 

  822. 

  823.   test "can override format with parameter negative" do
    824. 

  824.     request = stub_request("QUERY_STRING" => "format=txt")
    825. 

  825. 

  826.     assert_not_predicate request.format, :xml?
    827. 

  827.   end
    828. 

  828. 

  829.   test "can override format with parameter positive" do
    830. 

  830.     request = stub_request("QUERY_STRING" => "format=xml")
    831. 

  831. 

  832.     assert_predicate request.format, :xml?
    833. 

  833.   end
    834. 

  834. 

  835.   test "formats text/html with accept header" do
    836. 

  836.     request = stub_request "HTTP_ACCEPT" => "text/html"
    837. 

  837.     assert_equal [Mime[:html]], request.formats
    838. 

  838.   end
    839. 

  839. 

  840.   test "formats blank with accept header" do
    841. 

  841.     request = stub_request "HTTP_ACCEPT" => ""
    842. 

  842.     assert_equal [Mime[:html]], request.formats
    843. 

  843.   end
    844. 

  844. 

  845.   test "formats XMLHttpRequest with accept header" do
    846. 

  846.     request = stub_request "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest"
    847. 

  847.     assert_equal [Mime[:js]], request.formats
    848. 

  848.   end
    849. 

  849. 

  850.   test "formats application/xml with accept header" do
    851. 

  851.     request = stub_request("CONTENT_TYPE" => "application/xml; charset=UTF-8",
    852. 

  852.                            "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest")
    853. 

  853.     assert_equal [Mime[:xml]], request.formats
    854. 

  854.   end
    855. 

  855. 

  856.   test "formats format:text with accept header" do
    857. 

  857.     request = stub_request("QUERY_STRING" => "format=txt")
    858. 

  858. 

  859.     assert_equal [Mime[:text]], request.formats
    860. 

  860.   end
    861. 

  861. 

  862.   test "formats format:unknown with accept header" do
    863. 

  863.     request = stub_request("QUERY_STRING" => "format=unknown")
    864. 

  864. 

  865.     assert_instance_of Mime::NullType, request.format
    866. 

  866.   end
    867. 

  867. 

  868.   test "format is not nil with unknown format" do
    869. 

  869.     request = stub_request("QUERY_STRING" => "format=hello")
    870. 

  870. 

  871.     assert_nil request.format
    872. 

  872.     assert_not_predicate request.format, :html?
    873. 

  873.     assert_not_predicate request.format, :xml?
    874. 

  874.     assert_not_predicate request.format, :json?
    875. 

  875.   end
    876. 

  876. 

  877.   test "format does not throw exceptions when malformed GET parameters" do
    878. 

  878.     request = stub_request("QUERY_STRING" => "x[y]=1&x[y][][w]=2")
    879. 

  879.     assert request.formats
    880. 

  880.     assert_predicate request.format, :html?
    881. 

  881.   end
    882. 

  882. 

  883.   test "format does not throw exceptions when invalid POST parameters" do
    884. 

  884.     body = "{record:{content:127.0.0.1}}"
    885. 

  885.     request = stub_request(
    886. 

  886.       "REQUEST_METHOD" => "POST",
    887. 

  887.       "CONTENT_LENGTH" => body.length,
    888. 

  888.       "CONTENT_TYPE" => "application/json",
    889. 

  889.       "rack.input" => StringIO.new(body),
    890. 

  890.       "action_dispatch.logger" => Logger.new(output = StringIO.new)
    891. 

  891.     )
    892. 

  892.     assert request.formats
    893. 

  893.     assert request.format.html?
    894. 

  894. 

  895.     output.rewind && (err = output.read)
    896. 

  896.     assert_match(/Error occurred while parsing request parameters/, err)
    897. 

  897.   end
    898. 

  898. 

  899.   test "formats with xhr request" do
    900. 

  900.     request = stub_request "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest",
    901. 

  901.                            "QUERY_STRING" => ""
    902. 

  902. 

  903.     assert_equal [Mime[:js]], request.formats
    904. 

  904.   end
    905. 

  905. 

  906.   test "ignore_accept_header" do
    907. 

  907.     old_ignore_accept_header = ActionDispatch::Request.ignore_accept_header
    908. 

  908.     ActionDispatch::Request.ignore_accept_header = true
    909. 

  909. 

  910.     begin
    911. 

  911.       request = stub_request "HTTP_ACCEPT" => "application/xml",
    912. 

  912.                              "QUERY_STRING" => ""
    913. 

  913. 

  914.       assert_equal [ Mime[:html] ], request.formats
    915. 

  915. 

  916.       request = stub_request "HTTP_ACCEPT" => "koz-asked/something-crazy",
    917. 

  917.                              "QUERY_STRING" => ""
    918. 

  918. 

  919.       assert_equal [ Mime[:html] ], request.formats
    920. 

  920. 

  921.       request = stub_request "HTTP_ACCEPT" => "*/*;q=0.1",
    922. 

  922.                              "QUERY_STRING" => ""
    923. 

  923. 

  924.       assert_equal [ Mime[:html] ], request.formats
    925. 

  925. 

  926.       request = stub_request "HTTP_ACCEPT" => "application/jxw",
    927. 

  927.                              "QUERY_STRING" => ""
    928. 

  928. 

  929.       assert_equal [ Mime[:html] ], request.formats
    930. 

  930. 

  931.       request = stub_request "HTTP_ACCEPT" => "application/xml",
    932. 

  932.                              "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest",
    933. 

  933.                              "QUERY_STRING" => ""
    934. 

  934. 

  935.       assert_equal [ Mime[:js] ], request.formats
    936. 

  936. 

  937.       request = stub_request "HTTP_ACCEPT" => "application/xml",
    938. 

  938.                              "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest",
    939. 

  939.                              "QUERY_STRING" => "format=json"
    940. 

  940. 

  941.       assert_equal [ Mime[:json] ], request.formats
    942. 

  942.     ensure
    943. 

  943.       ActionDispatch::Request.ignore_accept_header = old_ignore_accept_header
    944. 

  944.     end
    945. 

  945.   end
    946. 

  946. 

  947.   test "format taken from the path extension" do
    948. 

  948.     request = stub_request "PATH_INFO" => "/foo.xml", "QUERY_STRING" => ""
    949. 

  949. 

  950.     assert_equal [Mime[:xml]], request.formats
    951. 

  951. 

  952.     request = stub_request "PATH_INFO" => "/foo.123", "QUERY_STRING" => ""
    953. 

  953. 

  954.     assert_equal [Mime[:html]], request.formats
    955. 

  955.   end
    956. 

  956. 

  957.   test "formats from accept headers have higher precedence than path extension" do
    958. 

  958.     request = stub_request "HTTP_ACCEPT" => "application/json",
    959. 

  959.                            "PATH_INFO" => "/foo.xml",
    960. 

  960.                            "QUERY_STRING" => ""
    961. 

  961. 

  962.     assert_equal [Mime[:json]], request.formats
    963. 

  963.   end
    964. 

  964. end
    965. 

  965. 

  966. class RequestMimeType < BaseRequestTest
    967. 

  967.   test "content type" do
    968. 

  968.     assert_equal Mime[:html], stub_request("CONTENT_TYPE" => "text/html").content_mime_type
    969. 

  969.   end
    970. 

  970. 

  971.   test "no content type" do
    972. 

  972.     assert_nil stub_request.content_mime_type
    973. 

  973.   end
    974. 

  974. 

  975.   test "content type is XML" do
    976. 

  976.     assert_equal Mime[:xml], stub_request("CONTENT_TYPE" => "application/xml").content_mime_type
    977. 

  977.   end
    978. 

  978. 

  979.   test "content type with charset" do
    980. 

  980.     assert_equal Mime[:xml], stub_request("CONTENT_TYPE" => "application/xml; charset=UTF-8").content_mime_type
    981. 

  981.   end
    982. 

  982. 

  983.   test "user agent" do
    984. 

  984.     assert_equal "TestAgent", stub_request("HTTP_USER_AGENT" => "TestAgent").user_agent
    985. 

  985.   end
    986. 

  986. 

  987.   test "negotiate_mime" do
    988. 

  988.     request = stub_request(
    989. 

  989.       "HTTP_ACCEPT" => "text/html",
    990. 

  990.       "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest"
    991. 

  991.     )
    992. 

  992. 

  993.     assert_nil request.negotiate_mime([Mime[:xml], Mime[:json]])
    994. 

  994.     assert_equal Mime[:html], request.negotiate_mime([Mime[:xml], Mime[:html]])
    995. 

  995.     assert_equal Mime[:html], request.negotiate_mime([Mime[:xml], Mime::ALL])
    996. 

  996.   end
    997. 

  997. 

  998.   test "negotiate_mime with content_type" do
    999. 

  999.     request = stub_request(
    1000. 

  1000.       "CONTENT_TYPE" => "application/xml; charset=UTF-8",
    1001. 

  1001.       "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest"
    1002. 

  1002.     )
    1003. 

  1003. 

  1004.     assert_equal Mime[:xml], request.negotiate_mime([Mime[:xml], Mime[:csv]])
    1005. 

  1005.   end
    1006. 

  1006. end
    1007. 

  1007. 

  1008. class RequestParameters < BaseRequestTest
    1009. 

  1009.   test "parameters" do
    1010. 

  1010.     request = stub_request "CONTENT_TYPE" => "application/json",
    1011. 

  1011.                            "CONTENT_LENGTH" => 9,
    1012. 

  1012.                            "RAW_POST_DATA" => '{"foo":1}',
    1013. 

  1013.                            "QUERY_STRING" => "bar=2"
    1014. 

  1014. 

  1015.     assert_equal({ "foo" => 1, "bar" => "2" }, request.parameters)
    1016. 

  1016.     assert_equal({ "foo" => 1 }, request.request_parameters)
    1017. 

  1017.     assert_equal({ "bar" => "2" }, request.query_parameters)
    1018. 

  1018.   end
    1019. 

  1019. 

  1020.   test "parameters not accessible after rack parse error" do
    1021. 

  1021.     request = stub_request("QUERY_STRING" => "x[y]=1&x[y][][w]=2")
    1022. 

  1022. 

  1023.     2.times do
    1024. 

  1024.       assert_raises(ActionController::BadRequest) do
    1025. 

  1025.         # rack will raise a Rack::Utils::ParameterTypeError when parsing this query string
    1026. 

  1026.         request.parameters
    1027. 

  1027.       end
    1028. 

  1028.     end
    1029. 

  1029.   end
    1030. 

  1030. 

  1031.   test "path parameters with invalid UTF8 encoding" do
    1032. 

  1032.     request = stub_request
    1033. 

  1033. 

  1034.     err = assert_raises(ActionController::BadRequest) do
    1035. 

  1035.       request.path_parameters = { foo: "\xBE" }
    1036. 

  1036.     end
    1037. 

  1037. 

  1038.     assert_predicate err.message, :valid_encoding?
    1039. 

  1039.     assert_equal "Invalid path parameters: Invalid encoding for parameter: �", err.message
    1040. 

  1040.   end
    1041. 

  1041. 

  1042.   test "parameters not accessible after rack parse error of invalid UTF8 character" do
    1043. 

  1043.     request = stub_request("QUERY_STRING" => "foo%81E=1")
    1044. 

  1044.     assert_raises(ActionController::BadRequest) { request.parameters }
    1045. 

  1045.   end
    1046. 

  1046. 

  1047.   test "parameters containing an invalid UTF8 character" do
    1048. 

  1048.     request = stub_request("QUERY_STRING" => "foo=%81E")
    1049. 

  1049.     assert_raises(ActionController::BadRequest) { request.parameters }
    1050. 

  1050.   end
    1051. 

  1051. 

  1052.   test "parameters containing a deeply nested invalid UTF8 character" do
    1053. 

  1053.     request = stub_request("QUERY_STRING" => "foo[bar]=%81E")
    1054. 

  1054.     assert_raises(ActionController::BadRequest) { request.parameters }
    1055. 

  1055.   end
    1056. 

  1056. 

  1057.   test "parameters not accessible after rack parse error 1" do
    1058. 

  1058.     request = stub_request(
    1059. 

  1059.       "REQUEST_METHOD" => "POST",
    1060. 

  1060.       "CONTENT_LENGTH" => "a%=".length,
    1061. 

  1061.       "CONTENT_TYPE" => "application/x-www-form-urlencoded; charset=utf-8",
    1062. 

  1062.       "rack.input" => StringIO.new("a%=")
    1063. 

  1063.     )
    1064. 

  1064. 

  1065.     assert_raises(ActionController::BadRequest) do
    1066. 

  1066.       # rack will raise a Rack::Utils::ParameterTypeError when parsing this query string
    1067. 

  1067.       request.parameters
    1068. 

  1068.     end
    1069. 

  1069.   end
    1070. 

  1070. 

  1071.   test "we have access to the original exception" do
    1072. 

  1072.     request = stub_request("QUERY_STRING" => "x[y]=1&x[y][][w]=2")
    1073. 

  1073. 

  1074.     e = assert_raises(ActionController::BadRequest) do
    1075. 

  1075.       # rack will raise a Rack::Utils::ParameterTypeError when parsing this query string
    1076. 

  1076.       request.parameters
    1077. 

  1077.     end
    1078. 

  1078. 

  1079.     assert_not_nil e.cause
    1080. 

  1080.     assert_equal e.cause.backtrace, e.backtrace
    1081. 

  1081.   end
    1082. 

  1082. end
    1083. 

  1083. 

  1084. class RequestParameterFilter < BaseRequestTest
    1085. 

  1085.   test "parameter filter is deprecated" do
    1086. 

  1086.     assert_deprecated do
    1087. 

  1087.       ActionDispatch::Http::ParameterFilter.new(["blah"])
    1088. 

  1088.     end
    1089. 

  1089.   end
    1090. 

  1090. 

  1091.   test "filtered_parameters returns params filtered" do
    1092. 

  1092.     request = stub_request(
    1093. 

  1093.       "action_dispatch.request.parameters" => {
    1094. 

  1094.         "lifo" => "Pratik",
    1095. 

  1095.         "amount" => "420",
    1096. 

  1096.         "step" => "1"
    1097. 

  1097.       },
    1098. 

  1098.       "action_dispatch.parameter_filter" => [:lifo, :amount]
    1099. 

  1099.     )
    1100. 

  1100. 

  1101.     params = request.filtered_parameters
    1102. 

  1102.     assert_equal "[FILTERED]", params["lifo"]
    1103. 

  1103.     assert_equal "[FILTERED]", params["amount"]
    1104. 

  1104.     assert_equal "1", params["step"]
    1105. 

  1105.   end
    1106. 

  1106. 

  1107.   test "filtered_env filters env as a whole" do
    1108. 

  1108.     request = stub_request(
    1109. 

  1109.       "action_dispatch.request.parameters" => {
    1110. 

  1110.         "amount" => "420",
    1111. 

  1111.         "step" => "1"
    1112. 

  1112.       },
    1113. 

  1113.       "RAW_POST_DATA" => "yada yada",
    1114. 

  1114.       "action_dispatch.parameter_filter" => [:lifo, :amount]
    1115. 

  1115.     )
    1116. 

  1116.     request = stub_request(request.filtered_env)
    1117. 

  1117. 

  1118.     assert_equal "[FILTERED]", request.raw_post
    1119. 

  1119.     assert_equal "[FILTERED]", request.params["amount"]
    1120. 

  1120.     assert_equal "1", request.params["step"]
    1121. 

  1121.   end
    1122. 

  1122. 

  1123.   test "filtered_path returns path with filtered query string" do
    1124. 

  1124.     %w(; &).each do |sep|
    1125. 

  1125.       request = stub_request(
    1126. 

  1126.         "QUERY_STRING" => %w(username=sikachu secret=bd4f21f api_key=b1bc3b3cd352f68d79d7).join(sep),
    1127. 

  1127.         "PATH_INFO" => "/authenticate",
    1128. 

  1128.         "action_dispatch.parameter_filter" => [:secret, :api_key]
    1129. 

  1129.       )
    1130. 

  1130. 

  1131.       path = request.filtered_path
    1132. 

  1132.       assert_equal %w(/authenticate?username=sikachu secret=[FILTERED] api_key=[FILTERED]).join(sep), path
    1133. 

  1133.     end
    1134. 

  1134.   end
    1135. 

  1135. 

  1136.   test "filtered_path should not unescape a genuine '[FILTERED]' value" do
    1137. 

  1137.     request = stub_request(
    1138. 

  1138.       "QUERY_STRING" => "secret=bd4f21f&genuine=%5BFILTERED%5D",
    1139. 

  1139.       "PATH_INFO" => "/authenticate",
    1140. 

  1140.       "action_dispatch.parameter_filter" => [:secret]
    1141. 

  1141.     )
    1142. 

  1142. 

  1143.     path = request.filtered_path
    1144. 

  1144.     assert_equal request.script_name + "/authenticate?secret=[FILTERED]&genuine=%5BFILTERED%5D", path
    1145. 

  1145.   end
    1146. 

  1146. 

  1147.   test "filtered_path should preserve duplication of keys in query string" do
    1148. 

  1148.     request = stub_request(
    1149. 

  1149.       "QUERY_STRING" => "username=sikachu&secret=bd4f21f&username=fxn",
    1150. 

  1150.       "PATH_INFO" => "/authenticate",
    1151. 

  1151.       "action_dispatch.parameter_filter" => [:secret]
    1152. 

  1152.     )
    1153. 

  1153. 

  1154.     path = request.filtered_path
    1155. 

  1155.     assert_equal request.script_name + "/authenticate?username=sikachu&secret=[FILTERED]&username=fxn", path
    1156. 

  1156.   end
    1157. 

  1157. 

  1158.   test "filtered_path should ignore searchparts" do
    1159. 

  1159.     request = stub_request(
    1160. 

  1160.       "QUERY_STRING" => "secret",
    1161. 

  1161.       "PATH_INFO" => "/authenticate",
    1162. 

  1162.       "action_dispatch.parameter_filter" => [:secret]
    1163. 

  1163.     )
    1164. 

  1164. 

  1165.     path = request.filtered_path
    1166. 

  1166.     assert_equal request.script_name + "/authenticate?secret", path
    1167. 

  1167.   end
    1168. 

  1168. end
    1169. 

  1169. 

  1170. class RequestEtag < BaseRequestTest
    1171. 

  1171.   test "always matches *" do
    1172. 

  1172.     request = stub_request("HTTP_IF_NONE_MATCH" => "*")
    1173. 

  1173. 

  1174.     assert_equal "*", request.if_none_match
    1175. 

  1175.     assert_equal ["*"], request.if_none_match_etags
    1176. 

  1176. 

  1177.     assert request.etag_matches?('"strong"')
    1178. 

  1178.     assert request.etag_matches?('W/"weak"')
    1179. 

  1179.     assert_not request.etag_matches?(nil)
    1180. 

  1180.   end
    1181. 

  1181. 

  1182.   test "doesn't match absent If-None-Match" do
    1183. 

  1183.     request = stub_request
    1184. 

  1184. 

  1185.     assert_nil request.if_none_match
    1186. 

  1186.     assert_equal [], request.if_none_match_etags
    1187. 

  1187. 

  1188.     assert_not request.etag_matches?("foo")
    1189. 

  1189.     assert_not request.etag_matches?(nil)
    1190. 

  1190.   end
    1191. 

  1191. 

  1192.   test "matches opaque ETag validators without unquoting" do
    1193. 

  1193.     header = '"the-etag"'
    1194. 

  1194.     request = stub_request("HTTP_IF_NONE_MATCH" => header)
    1195. 

  1195. 

  1196.     assert_equal header, request.if_none_match
    1197. 

  1197.     assert_equal ['"the-etag"'], request.if_none_match_etags
    1198. 

  1198. 

  1199.     assert request.etag_matches?('"the-etag"')
    1200. 

  1200.     assert_not request.etag_matches?("the-etag")
    1201. 

  1201.   end
    1202. 

  1202. 

  1203.   test "if_none_match_etags multiple" do
    1204. 

  1204.     header = 'etag1, etag2, "third etag", "etag4"'
    1205. 

  1205.     expected = ["etag1", "etag2", '"third etag"', '"etag4"']
    1206. 

  1206.     request = stub_request("HTTP_IF_NONE_MATCH" => header)
    1207. 

  1207. 

  1208.     assert_equal header, request.if_none_match
    1209. 

  1209.     assert_equal expected, request.if_none_match_etags
    1210. 

  1210.     expected.each do |etag|
    1211. 

  1211.       assert request.etag_matches?(etag), etag
    1212. 

  1212.     end
    1213. 

  1213.   end
    1214. 

  1214. end
    1215. 

  1215. 

  1216. class RequestVariant < BaseRequestTest
    1217. 

  1217.   def setup
    1218. 

  1218.     super
    1219. 

  1219.     @request = stub_request
    1220. 

  1220.   end
    1221. 

  1221. 

  1222.   test "setting variant to a symbol" do
    1223. 

  1223.     @request.variant = :phone
    1224. 

  1224. 

  1225.     assert_predicate @request.variant, :phone?
    1226. 

  1226.     assert_not_predicate @request.variant, :tablet?
    1227. 

  1227.     assert @request.variant.any?(:phone, :tablet)
    1228. 

  1228.     assert_not @request.variant.any?(:tablet, :desktop)
    1229. 

  1229.   end
    1230. 

  1230. 

  1231.   test "setting variant to an array of symbols" do
    1232. 

  1232.     @request.variant = [:phone, :tablet]
    1233. 

  1233. 

  1234.     assert_predicate @request.variant, :phone?
    1235. 

  1235.     assert_predicate @request.variant, :tablet?
    1236. 

  1236.     assert_not_predicate @request.variant, :desktop?
    1237. 

  1237.     assert @request.variant.any?(:tablet, :desktop)
    1238. 

  1238.     assert_not @request.variant.any?(:desktop, :watch)
    1239. 

  1239.   end
    1240. 

  1240. 

  1241.   test "clearing variant" do
    1242. 

  1242.     @request.variant = nil
    1243. 

  1243. 

  1244.     assert_empty @request.variant
    1245. 

  1245.     assert_not_predicate @request.variant, :phone?
    1246. 

  1246.     assert_not @request.variant.any?(:phone, :tablet)
    1247. 

  1247.   end
    1248. 

  1248. 

  1249.   test "setting variant to a non-symbol value" do
    1250. 

  1250.     assert_raise ArgumentError do
    1251. 

  1251.       @request.variant = "phone"
    1252. 

  1252.     end
    1253. 

  1253.   end
    1254. 

  1254. 

  1255.   test "setting variant to an array containing a non-symbol value" do
    1256. 

  1256.     assert_raise ArgumentError do
    1257. 

  1257.       @request.variant = [:phone, "tablet"]
    1258. 

  1258.     end
    1259. 

  1259.   end
    1260. 

  1260. end
    1261. 

  1261. 

  1262. class RequestFormData < BaseRequestTest
    1263. 

  1263.   test "media_type is from the FORM_DATA_MEDIA_TYPES array" do
    1264. 

  1264.     assert_predicate stub_request("CONTENT_TYPE" => "application/x-www-form-urlencoded"), :form_data?
    1265. 

  1265.     assert_predicate stub_request("CONTENT_TYPE" => "multipart/form-data"), :form_data?
    1266. 

  1266.   end
    1267. 

  1267. 

  1268.   test "media_type is not from the FORM_DATA_MEDIA_TYPES array" do
    1269. 

  1269.     assert_not_predicate stub_request("CONTENT_TYPE" => "application/xml"), :form_data?
    1270. 

  1270.     assert_not_predicate stub_request("CONTENT_TYPE" => "multipart/related"), :form_data?
    1271. 

  1271.   end
    1272. 

  1272. 

  1273.   test "no Content-Type header is provided and the request_method is POST" do
    1274. 

  1274.     request = stub_request("REQUEST_METHOD" => "POST")
    1275. 

  1275. 

  1276.     assert_equal "", request.media_type
    1277. 

  1277.     assert_equal "POST", request.request_method
    1278. 

  1278.     assert_not_predicate request, :form_data?
    1279. 

  1279.   end
    1280. 

  1280. end
    1281. 

  1281. 

  1282. class EarlyHintsRequestTest < BaseRequestTest
    1283. 

  1283.   def setup
    1284. 

  1284.     super
    1285. 

  1285.     @env["rack.early_hints"] = lambda { |links| links }
    1286. 

  1286.     @request = stub_request
    1287. 

  1287.   end
    1288. 

  1288. 

  1289.   test "when early hints is set in the env link headers are sent" do
    1290. 

  1290.     early_hints = @request.send_early_hints("Link" => "</style.css>; rel=preload; as=style\n</script.js>; rel=preload")
    1291. 

  1291.     expected_hints = { "Link" => "</style.css>; rel=preload; as=style\n</script.js>; rel=preload" }
    1292. 

  1292. 

  1293.     assert_equal expected_hints, early_hints
    1294. 

  1294.   end
    1295. 

  1295. end
    1296. 

  1296.