1berry/ruby
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Guard CGI examples with Ruby 3.5 and use cgi/escape for related examples

Browse Source
This commit is contained in:
Hiroshi SHIBATA 2025-05-08 19:41:20 +09:00
parent 600c616507
commit ce6c1778fb
Notes: git 2025-05-09 05:27:42 +00:00 
Merged: https://github.com/ruby/ruby/pull/13275
87 changed files with 2412 additions and 2144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
spec/ruby/library/cgi/cookie/domain_spec.rb
View File

@ -1,23 +1,26 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::Cookie#domain" do ruby_version_is ""..."3.5" do
it "returns self's domain" do require 'cgi'
cookie = CGI::Cookie.new("test-cookie")
cookie.domain.should be_nil
cookie = CGI::Cookie.new("name" => "test-cookie", "domain" => "example.com") describe "CGI::Cookie#domain" do
cookie.domain.should == "example.com" it "returns self's domain" do
end cookie = CGI::Cookie.new("test-cookie")
end cookie.domain.should be_nil
describe "CGI::Cookie#domain=" do cookie = CGI::Cookie.new("name" => "test-cookie", "domain" => "example.com")
it "sets self's domain" do cookie.domain.should == "example.com"
cookie = CGI::Cookie.new("test-cookie") end
cookie.domain = "test.com" end
cookie.domain.should == "test.com"
describe "CGI::Cookie#domain=" do
cookie.domain = "example.com" it "sets self's domain" do
cookie.domain.should == "example.com" cookie = CGI::Cookie.new("test-cookie")
cookie.domain = "test.com"
cookie.domain.should == "test.com"
cookie.domain = "example.com"
cookie.domain.should == "example.com"
end
end end
end end

39
spec/ruby/library/cgi/cookie/expires_spec.rb
View File

@ -1,23 +1,26 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::Cookie#expires" do ruby_version_is ""..."3.5" do
it "returns self's expiration date" do require 'cgi'
cookie = CGI::Cookie.new("test-cookie")
cookie.expires.should be_nil
cookie = CGI::Cookie.new("name" => "test-cookie", "expires" => Time.at(1196524602)) describe "CGI::Cookie#expires" do
cookie.expires.should == Time.at(1196524602) it "returns self's expiration date" do
end cookie = CGI::Cookie.new("test-cookie")
end cookie.expires.should be_nil
describe "CGI::Cookie#expires=" do cookie = CGI::Cookie.new("name" => "test-cookie", "expires" => Time.at(1196524602))
it "sets self's expiration date" do cookie.expires.should == Time.at(1196524602)
cookie = CGI::Cookie.new("test-cookie") end
cookie.expires = Time.at(1196524602) end
cookie.expires.should == Time.at(1196524602)
describe "CGI::Cookie#expires=" do
cookie.expires = Time.at(1196525000) it "sets self's expiration date" do
cookie.expires.should == Time.at(1196525000) cookie = CGI::Cookie.new("test-cookie")
cookie.expires = Time.at(1196524602)
cookie.expires.should == Time.at(1196524602)
cookie.expires = Time.at(1196525000)
cookie.expires.should == Time.at(1196525000)
end
end end
end end

247
spec/ruby/library/cgi/cookie/initialize_spec.rb
View File

@ -1,147 +1,150 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::Cookie#initialize when passed String" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@cookie = CGI::Cookie.allocate
end
it "sets the self's name to the passed String" do describe "CGI::Cookie#initialize when passed String" do
@cookie.send(:initialize, "test-cookie") before :each do
@cookie.name.should == "test-cookie" @cookie = CGI::Cookie.allocate
end end
it "sets the self's value to an empty Array" do it "sets the self's name to the passed String" do
@cookie.send(:initialize, "test-cookie")
@cookie.value.should == []
end
it "sets self to a non-secure cookie" do
@cookie.send(:initialize, "test")
@cookie.secure.should be_false
end
it "does set self's path to an empty String when ENV[\"SCRIPT_NAME\"] is not set" do
@cookie.send(:initialize, "test-cookie")
@cookie.path.should == ""
end
it "does set self's path based on ENV[\"SCRIPT_NAME\"] when ENV[\"SCRIPT_NAME\"] is set" do
old_script_name = ENV["SCRIPT_NAME"]
begin
ENV["SCRIPT_NAME"] = "some/path/script.rb"
@cookie.send(:initialize, "test-cookie") @cookie.send(:initialize, "test-cookie")
@cookie.path.should == "some/path/" @cookie.name.should == "test-cookie"
end
ENV["SCRIPT_NAME"] = "script.rb" it "sets the self's value to an empty Array" do
@cookie.send(:initialize, "test-cookie")
@cookie.value.should == []
end
it "sets self to a non-secure cookie" do
@cookie.send(:initialize, "test")
@cookie.secure.should be_false
end
it "does set self's path to an empty String when ENV[\"SCRIPT_NAME\"] is not set" do
@cookie.send(:initialize, "test-cookie") @cookie.send(:initialize, "test-cookie")
@cookie.path.should == "" @cookie.path.should == ""
end
ENV["SCRIPT_NAME"] = nil it "does set self's path based on ENV[\"SCRIPT_NAME\"] when ENV[\"SCRIPT_NAME\"] is set" do
@cookie.send(:initialize, "test-cookie") old_script_name = ENV["SCRIPT_NAME"]
@cookie.path.should == ""
ensure begin
ENV["SCRIPT_NAME"] = old_script_name ENV["SCRIPT_NAME"] = "some/path/script.rb"
@cookie.send(:initialize, "test-cookie")
@cookie.path.should == "some/path/"
ENV["SCRIPT_NAME"] = "script.rb"
@cookie.send(:initialize, "test-cookie")
@cookie.path.should == ""
ENV["SCRIPT_NAME"] = nil
@cookie.send(:initialize, "test-cookie")
@cookie.path.should == ""
ensure
ENV["SCRIPT_NAME"] = old_script_name
end
end
it "does not set self's expiration date" do
@cookie.expires.should be_nil
end
it "does not set self's domain" do
@cookie.domain.should be_nil
end end
end end
it "does not set self's expiration date" do describe "CGI::Cookie#initialize when passed Hash" do
@cookie.expires.should be_nil before :each do
end @cookie = CGI::Cookie.allocate
end
it "does not set self's domain" do it "sets self's contents based on the passed Hash" do
@cookie.domain.should be_nil @cookie.send(:initialize,
end 'name' => 'test-cookie',
end 'value' => ["one", "two", "three"],
'path' => 'some/path/',
'domain' => 'example.com',
'expires' => Time.at(1196524602),
'secure' => true)
describe "CGI::Cookie#initialize when passed Hash" do @cookie.name.should == "test-cookie"
before :each do @cookie.value.should == ["one", "two", "three"]
@cookie = CGI::Cookie.allocate
end
it "sets self's contents based on the passed Hash" do
@cookie.send(:initialize,
'name' => 'test-cookie',
'value' => ["one", "two", "three"],
'path' => 'some/path/',
'domain' => 'example.com',
'expires' => Time.at(1196524602),
'secure' => true)
@cookie.name.should == "test-cookie"
@cookie.value.should == ["one", "two", "three"]
@cookie.path.should == "some/path/"
@cookie.domain.should == "example.com"
@cookie.expires.should == Time.at(1196524602)
@cookie.secure.should be_true
end
it "does set self's path based on ENV[\"SCRIPT_NAME\"] when the Hash has no 'path' entry" do
old_script_name = ENV["SCRIPT_NAME"]
begin
ENV["SCRIPT_NAME"] = "some/path/script.rb"
@cookie.send(:initialize, 'name' => 'test-cookie')
@cookie.path.should == "some/path/" @cookie.path.should == "some/path/"
@cookie.domain.should == "example.com"
@cookie.expires.should == Time.at(1196524602)
@cookie.secure.should be_true
end
ENV["SCRIPT_NAME"] = "script.rb" it "does set self's path based on ENV[\"SCRIPT_NAME\"] when the Hash has no 'path' entry" do
@cookie.send(:initialize, 'name' => 'test-cookie') old_script_name = ENV["SCRIPT_NAME"]
@cookie.path.should == ""
ENV["SCRIPT_NAME"] = nil begin
@cookie.send(:initialize, 'name' => 'test-cookie') ENV["SCRIPT_NAME"] = "some/path/script.rb"
@cookie.path.should == "" @cookie.send(:initialize, 'name' => 'test-cookie')
ensure @cookie.path.should == "some/path/"
ENV["SCRIPT_NAME"] = old_script_name
ENV["SCRIPT_NAME"] = "script.rb"
@cookie.send(:initialize, 'name' => 'test-cookie')
@cookie.path.should == ""
ENV["SCRIPT_NAME"] = nil
@cookie.send(:initialize, 'name' => 'test-cookie')
@cookie.path.should == ""
ensure
ENV["SCRIPT_NAME"] = old_script_name
end
end
it "tries to convert the Hash's 'value' to an Array using #Array" do
obj = mock("Converted To Array")
obj.should_receive(:to_ary).and_return(["1", "2", "3"])
@cookie.send(:initialize,
'name' => 'test-cookie',
'value' => obj)
@cookie.value.should == [ "1", "2", "3" ]
obj = mock("Converted To Array")
obj.should_receive(:to_a).and_return(["one", "two", "three"])
@cookie.send(:initialize,
'name' => 'test-cookie',
'value' => obj)
@cookie.value.should == [ "one", "two", "three" ]
obj = mock("Put into an Array")
@cookie.send(:initialize,
'name' => 'test-cookie',
'value' => obj)
@cookie.value.should == [ obj ]
end
it "raises a ArgumentError when the passed Hash has no 'name' entry" do
-> { @cookie.send(:initialize, {}) }.should raise_error(ArgumentError)
-> { @cookie.send(:initialize, "value" => "test") }.should raise_error(ArgumentError)
end end
end end
it "tries to convert the Hash's 'value' to an Array using #Array" do describe "CGI::Cookie#initialize when passed String, values ..." do
obj = mock("Converted To Array") before :each do
obj.should_receive(:to_ary).and_return(["1", "2", "3"]) @cookie = CGI::Cookie.allocate
@cookie.send(:initialize, end
'name' => 'test-cookie',
'value' => obj)
@cookie.value.should == [ "1", "2", "3" ]
obj = mock("Converted To Array") it "sets the self's name to the passed String" do
obj.should_receive(:to_a).and_return(["one", "two", "three"]) @cookie.send(:initialize, "test-cookie", "one", "two", "three")
@cookie.send(:initialize, @cookie.name.should == "test-cookie"
'name' => 'test-cookie', end
'value' => obj)
@cookie.value.should == [ "one", "two", "three" ]
obj = mock("Put into an Array") it "sets the self's value to an Array containing all passed values" do
@cookie.send(:initialize, @cookie.send(:initialize, "test-cookie", "one", "two", "three")
'name' => 'test-cookie', @cookie.value.should == ["one", "two", "three"]
'value' => obj) end
@cookie.value.should == [ obj ]
end
it "raises a ArgumentError when the passed Hash has no 'name' entry" do it "sets self to a non-secure cookie" do
-> { @cookie.send(:initialize, {}) }.should raise_error(ArgumentError) @cookie.send(:initialize, "test", "one", "two", "three")
-> { @cookie.send(:initialize, "value" => "test") }.should raise_error(ArgumentError) @cookie.secure.should be_false
end end
end
describe "CGI::Cookie#initialize when passed String, values ..." do
before :each do
@cookie = CGI::Cookie.allocate
end
it "sets the self's name to the passed String" do
@cookie.send(:initialize, "test-cookie", "one", "two", "three")
@cookie.name.should == "test-cookie"
end
it "sets the self's value to an Array containing all passed values" do
@cookie.send(:initialize, "test-cookie", "one", "two", "three")
@cookie.value.should == ["one", "two", "three"]
end
it "sets self to a non-secure cookie" do
@cookie.send(:initialize, "test", "one", "two", "three")
@cookie.secure.should be_false
end end
end end

39
spec/ruby/library/cgi/cookie/name_spec.rb
View File

@ -1,23 +1,26 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::Cookie#name" do ruby_version_is ""..."3.5" do
it "returns self's name" do require 'cgi'
cookie = CGI::Cookie.new("test-cookie")
cookie.name.should == "test-cookie"
cookie = CGI::Cookie.new("name" => "another-cookie") describe "CGI::Cookie#name" do
cookie.name.should == "another-cookie" it "returns self's name" do
end cookie = CGI::Cookie.new("test-cookie")
end cookie.name.should == "test-cookie"
describe "CGI::Cookie#name=" do cookie = CGI::Cookie.new("name" => "another-cookie")
it "sets self's expiration date" do cookie.name.should == "another-cookie"
cookie = CGI::Cookie.new("test-cookie") end
cookie.name = "another-name" end
cookie.name.should == "another-name"
describe "CGI::Cookie#name=" do
cookie.name = "and-one-more" it "sets self's expiration date" do
cookie.name.should == "and-one-more" cookie = CGI::Cookie.new("test-cookie")
cookie.name = "another-name"
cookie.name.should == "another-name"
cookie.name = "and-one-more"
cookie.name.should == "and-one-more"
end
end end
end end

41
spec/ruby/library/cgi/cookie/parse_spec.rb
View File

@ -1,26 +1,29 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::Cookie.parse" do ruby_version_is ""..."3.5" do
it "parses a raw cookie string into a hash of Cookies" do require 'cgi'
expected = { "test-cookie" => ["one", "two", "three"] }
CGI::Cookie.parse("test-cookie=one&two&three").should == expected
expected = { "second-cookie" => ["three", "four"], "first-cookie" => ["one", "two"] } describe "CGI::Cookie.parse" do
CGI::Cookie.parse("first-cookie=one&two;second-cookie=three&four").should == expected it "parses a raw cookie string into a hash of Cookies" do
end expected = { "test-cookie" => ["one", "two", "three"] }
CGI::Cookie.parse("test-cookie=one&two&three").should == expected
it "does not use , for cookie separators" do expected = { "second-cookie" => ["three", "four"], "first-cookie" => ["one", "two"] }
expected = { CGI::Cookie.parse("first-cookie=one&two;second-cookie=three&four").should == expected
"first-cookie" => ["one", "two"], end
"second-cookie" => ["three", "four,third_cookie=five", "six"]
}
CGI::Cookie.parse("first-cookie=one&two;second-cookie=three&four,third_cookie=five&six").should == expected
end
it "unescapes the Cookie values" do it "does not use , for cookie separators" do
cookie = "test-cookie=+%21%22%23%24%25%26%27%28%29%2A%2B%2C-.%2F0123456789%3A%3B%3C%3D%3E%3F%40ABCDEFGHIJKLMNOPQRSTUVWXYZ%5B%5C%5D%5E_%60abcdefghijklmnopqrstuvwxyz%7B%7C%7D%7E" expected = {
expected = { "test-cookie" => [ " !\"\#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~" ] } "first-cookie" => ["one", "two"],
CGI::Cookie.parse(cookie).should == expected "second-cookie" => ["three", "four,third_cookie=five", "six"]
}
CGI::Cookie.parse("first-cookie=one&two;second-cookie=three&four,third_cookie=five&six").should == expected
end
it "unescapes the Cookie values" do
cookie = "test-cookie=+%21%22%23%24%25%26%27%28%29%2A%2B%2C-.%2F0123456789%3A%3B%3C%3D%3E%3F%40ABCDEFGHIJKLMNOPQRSTUVWXYZ%5B%5C%5D%5E_%60abcdefghijklmnopqrstuvwxyz%7B%7C%7D%7E"
expected = { "test-cookie" => [ " !\"\#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~" ] }
CGI::Cookie.parse(cookie).should == expected
end
end end
end end

39
spec/ruby/library/cgi/cookie/path_spec.rb
View File

@ -1,23 +1,26 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::Cookie#path" do ruby_version_is ""..."3.5" do
it "returns self's path" do require 'cgi'
cookie = CGI::Cookie.new("test-cookie")
cookie.path.should == ""
cookie = CGI::Cookie.new("name" => "test-cookie", "path" => "/some/path/") describe "CGI::Cookie#path" do
cookie.path.should == "/some/path/" it "returns self's path" do
end cookie = CGI::Cookie.new("test-cookie")
end cookie.path.should == ""
describe "CGI::Cookie#path=" do cookie = CGI::Cookie.new("name" => "test-cookie", "path" => "/some/path/")
it "sets self's path" do cookie.path.should == "/some/path/"
cookie = CGI::Cookie.new("test-cookie") end
cookie.path = "/some/path/" end
cookie.path.should == "/some/path/"
describe "CGI::Cookie#path=" do
cookie.path = "/another/path/" it "sets self's path" do
cookie.path.should == "/another/path/" cookie = CGI::Cookie.new("test-cookie")
cookie.path = "/some/path/"
cookie.path.should == "/some/path/"
cookie.path = "/another/path/"
cookie.path.should == "/another/path/"
end
end end
end end

129
spec/ruby/library/cgi/cookie/secure_spec.rb
View File

@ -1,70 +1,73 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::Cookie#secure" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@cookie = CGI::Cookie.new("test-cookie")
describe "CGI::Cookie#secure" do
before :each do
@cookie = CGI::Cookie.new("test-cookie")
end
it "returns whether self is a secure cookie or not" do
@cookie.secure = true
@cookie.secure.should be_true
@cookie.secure = false
@cookie.secure.should be_false
end
end end
it "returns whether self is a secure cookie or not" do describe "CGI::Cookie#secure= when passed true" do
@cookie.secure = true before :each do
@cookie.secure.should be_true @cookie = CGI::Cookie.new("test-cookie")
end
@cookie.secure = false it "returns true" do
@cookie.secure.should be_false (@cookie.secure = true).should be_true
end end
end
it "sets self to a secure cookie" do
describe "CGI::Cookie#secure= when passed true" do @cookie.secure = true
before :each do @cookie.secure.should be_true
@cookie = CGI::Cookie.new("test-cookie") end
end end
it "returns true" do describe "CGI::Cookie#secure= when passed false" do
(@cookie.secure = true).should be_true before :each do
end @cookie = CGI::Cookie.new("test-cookie")
end
it "sets self to a secure cookie" do
@cookie.secure = true it "returns false" do
@cookie.secure.should be_true (@cookie.secure = false).should be_false
end end
end
it "sets self to a non-secure cookie" do
describe "CGI::Cookie#secure= when passed false" do @cookie.secure = false
before :each do @cookie.secure.should be_false
@cookie = CGI::Cookie.new("test-cookie") end
end end
it "returns false" do describe "CGI::Cookie#secure= when passed Object" do
(@cookie.secure = false).should be_false before :each do
end @cookie = CGI::Cookie.new("test-cookie")
end
it "sets self to a non-secure cookie" do
@cookie.secure = false it "does not change self's secure value" do
@cookie.secure.should be_false @cookie.secure = false
end
end @cookie.secure = Object.new
@cookie.secure.should be_false
describe "CGI::Cookie#secure= when passed Object" do
before :each do @cookie.secure = "Test"
@cookie = CGI::Cookie.new("test-cookie") @cookie.secure.should be_false
end
@cookie.secure = true
it "does not change self's secure value" do
@cookie.secure = false @cookie.secure = Object.new
@cookie.secure.should be_true
@cookie.secure = Object.new
@cookie.secure.should be_false @cookie.secure = "Test"
@cookie.secure.should be_true
@cookie.secure = "Test" end
@cookie.secure.should be_false
@cookie.secure = true
@cookie.secure = Object.new
@cookie.secure.should be_true
@cookie.secure = "Test"
@cookie.secure.should be_true
end end
end end

51
spec/ruby/library/cgi/cookie/to_s_spec.rb
View File

@ -1,33 +1,36 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::Cookie#to_s" do ruby_version_is ""..."3.5" do
it "returns a String representation of self" do require 'cgi'
cookie = CGI::Cookie.new("test-cookie")
cookie.to_s.should == "test-cookie=; path="
cookie = CGI::Cookie.new("test-cookie", "value") describe "CGI::Cookie#to_s" do
cookie.to_s.should == "test-cookie=value; path=" it "returns a String representation of self" do
cookie = CGI::Cookie.new("test-cookie")
cookie.to_s.should == "test-cookie=; path="
cookie = CGI::Cookie.new("test-cookie", "one", "two", "three") cookie = CGI::Cookie.new("test-cookie", "value")
cookie.to_s.should == "test-cookie=one&two&three; path=" cookie.to_s.should == "test-cookie=value; path="
cookie = CGI::Cookie.new( cookie = CGI::Cookie.new("test-cookie", "one", "two", "three")
'name' => 'test-cookie', cookie.to_s.should == "test-cookie=one&two&three; path="
'value' => ["one", "two", "three"],
'path' => 'some/path/',
'domain' => 'example.com',
'expires' => Time.at(1196524602),
'secure' => true)
cookie.to_s.should == "test-cookie=one&two&three; domain=example.com; path=some/path/; expires=Sat, 01 Dec 2007 15:56:42 GMT; secure"
end
it "escapes the self's values" do cookie = CGI::Cookie.new(
cookie = CGI::Cookie.new("test-cookie", " !\"\#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}") 'name' => 'test-cookie',
cookie.to_s.should == "test-cookie=+%21%22%23%24%25%26%27%28%29%2A%2B%2C-.%2F0123456789%3A%3B%3C%3D%3E%3F%40ABCDEFGHIJKLMNOPQRSTUVWXYZ%5B%5C%5D%5E_%60abcdefghijklmnopqrstuvwxyz%7B%7C%7D; path=" 'value' => ["one", "two", "three"],
end 'path' => 'some/path/',
'domain' => 'example.com',
'expires' => Time.at(1196524602),
'secure' => true)
cookie.to_s.should == "test-cookie=one&two&three; domain=example.com; path=some/path/; expires=Sat, 01 Dec 2007 15:56:42 GMT; secure"
end
it "does not escape tilde" do it "escapes the self's values" do
cookie = CGI::Cookie.new("test-cookie", "~").to_s.should == "test-cookie=~; path=" cookie = CGI::Cookie.new("test-cookie", " !\"\#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}")
cookie.to_s.should == "test-cookie=+%21%22%23%24%25%26%27%28%29%2A%2B%2C-.%2F0123456789%3A%3B%3C%3D%3E%3F%40ABCDEFGHIJKLMNOPQRSTUVWXYZ%5B%5C%5D%5E_%60abcdefghijklmnopqrstuvwxyz%7B%7C%7D; path="
end
it "does not escape tilde" do
cookie = CGI::Cookie.new("test-cookie", "~").to_s.should == "test-cookie=~; path="
end
end end
end end

137
spec/ruby/library/cgi/cookie/value_spec.rb
View File

@ -1,76 +1,79 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::Cookie#value" do ruby_version_is ""..."3.5" do
it "returns self's value" do require 'cgi'
cookie = CGI::Cookie.new("test-cookie")
cookie.value.should == []
cookie = CGI::Cookie.new("test-cookie", "one") describe "CGI::Cookie#value" do
cookie.value.should == ["one"] it "returns self's value" do
cookie = CGI::Cookie.new("test-cookie")
cookie.value.should == []
cookie = CGI::Cookie.new("test-cookie", "one", "two", "three") cookie = CGI::Cookie.new("test-cookie", "one")
cookie.value.should == ["one", "two", "three"] cookie.value.should == ["one"]
cookie = CGI::Cookie.new("name" => "test-cookie", "value" => ["one", "two", "three"]) cookie = CGI::Cookie.new("test-cookie", "one", "two", "three")
cookie.value.should == ["one", "two", "three"] cookie.value.should == ["one", "two", "three"]
end
it "is in synch with self" do cookie = CGI::Cookie.new("name" => "test-cookie", "value" => ["one", "two", "three"])
fail = [] cookie.value.should == ["one", "two", "three"]
[ end
:pop,
:shift, it "is in synch with self" do
[:<<, "Hello"], fail = []
[:push, "Hello"], [
[:unshift, "World"], :pop,
[:replace, ["A", "B"]], :shift,
[:[]=, 1, "Set"], [:<<, "Hello"],
[:delete, "first"], [:push, "Hello"],
[:delete_at, 0], [:unshift, "World"],
].each do |method, *args| [:replace, ["A", "B"]],
cookie1 = CGI::Cookie.new("test-cookie", "first", "second") [:[]=, 1, "Set"],
cookie2 = CGI::Cookie.new("test-cookie", "first", "second") [:delete, "first"],
cookie1.send(method, *args) [:delete_at, 0],
cookie2.value.send(method, *args) ].each do |method, *args|
fail << method unless cookie1.value == cookie2.value cookie1 = CGI::Cookie.new("test-cookie", "first", "second")
cookie2 = CGI::Cookie.new("test-cookie", "first", "second")
cookie1.send(method, *args)
cookie2.value.send(method, *args)
fail << method unless cookie1.value == cookie2.value
end
fail.should be_empty
end
end
describe "CGI::Cookie#value=" do
before :each do
@cookie = CGI::Cookie.new("test-cookie")
end
it "sets self's value" do
@cookie.value = ["one"]
@cookie.value.should == ["one"]
@cookie.value = ["one", "two", "three"]
@cookie.value.should == ["one", "two", "three"]
end
it "automatically converts the passed Object to an Array using #Array" do
@cookie.value = "test"
@cookie.value.should == ["test"]
obj = mock("to_a")
obj.should_receive(:to_a).and_return(["1", "2"])
@cookie.value = obj
@cookie.value.should == ["1", "2"]
obj = mock("to_ary")
obj.should_receive(:to_ary).and_return(["1", "2"])
@cookie.value = obj
@cookie.value.should == ["1", "2"]
end
it "does keep self and the values in sync" do
@cookie.value = ["one", "two", "three"]
@cookie[0].should == "one"
@cookie[1].should == "two"
@cookie[2].should == "three"
end end
fail.should be_empty
end
end
describe "CGI::Cookie#value=" do
before :each do
@cookie = CGI::Cookie.new("test-cookie")
end
it "sets self's value" do
@cookie.value = ["one"]
@cookie.value.should == ["one"]
@cookie.value = ["one", "two", "three"]
@cookie.value.should == ["one", "two", "three"]
end
it "automatically converts the passed Object to an Array using #Array" do
@cookie.value = "test"
@cookie.value.should == ["test"]
obj = mock("to_a")
obj.should_receive(:to_a).and_return(["1", "2"])
@cookie.value = obj
@cookie.value.should == ["1", "2"]
obj = mock("to_ary")
obj.should_receive(:to_ary).and_return(["1", "2"])
@cookie.value = obj
@cookie.value.should == ["1", "2"]
end
it "does keep self and the values in sync" do
@cookie.value = ["one", "two", "three"]
@cookie[0].should == "one"
@cookie[1].should == "two"
@cookie[2].should == "three"
end end
end end

6
spec/ruby/library/cgi/escapeElement_spec.rb
View File

@ -1,5 +1,9 @@
require_relative '../../spec_helper' require_relative '../../spec_helper'
require 'cgi' begin
require 'cgi/escape'
rescue LoadError
require 'cgi'
end
describe "CGI.escapeElement when passed String, elements, ..." do describe "CGI.escapeElement when passed String, elements, ..." do
it "escapes only the tags of the passed elements in the passed String" do it "escapes only the tags of the passed elements in the passed String" do

6
spec/ruby/library/cgi/escapeHTML_spec.rb
View File

@ -1,5 +1,9 @@
require_relative '../../spec_helper' require_relative '../../spec_helper'
require 'cgi' begin
require 'cgi/escape'
rescue LoadError
require 'cgi'
end
describe "CGI.escapeHTML" do describe "CGI.escapeHTML" do
it "escapes special HTML characters (&\"<>') in the passed argument" do it "escapes special HTML characters (&\"<>') in the passed argument" do

6
spec/ruby/library/cgi/escapeURIComponent_spec.rb
View File

@ -1,5 +1,9 @@
require_relative '../../spec_helper' require_relative '../../spec_helper'
require 'cgi' begin
require 'cgi/escape'
rescue LoadError
require 'cgi'
end
ruby_version_is "3.2" do ruby_version_is "3.2" do
describe "CGI.escapeURIComponent" do describe "CGI.escapeURIComponent" do

6
spec/ruby/library/cgi/escape_spec.rb
View File

@ -1,5 +1,9 @@
require_relative '../../spec_helper' require_relative '../../spec_helper'
require 'cgi' begin
require 'cgi/escape'
rescue LoadError
require 'cgi'
end
describe "CGI.escape" do describe "CGI.escape" do
it "url-encodes the passed argument" do it "url-encodes the passed argument" do

73
spec/ruby/library/cgi/htmlextension/a_spec.rb
View File

@ -1,49 +1,52 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
describe "CGI::HtmlExtension#a" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@html = CGISpecs.cgi_new require_relative 'fixtures/common'
end
describe "when passed a String" do describe "CGI::HtmlExtension#a" do
it "returns an 'a'-element, using the passed String as the 'href'-attribute" do before :each do
output = @html.a("http://www.example.com") @html = CGISpecs.cgi_new
output.should equal_element("A", "HREF" => "http://www.example.com")
end end
it "includes the passed block's return value when passed a block" do describe "when passed a String" do
output = @html.a("http://www.example.com") { "Example" } it "returns an 'a'-element, using the passed String as the 'href'-attribute" do
output.should equal_element("A", { "HREF" => "http://www.example.com" }, "Example") output = @html.a("http://www.example.com")
end output.should equal_element("A", "HREF" => "http://www.example.com")
end end
describe "when passed a Hash" do it "includes the passed block's return value when passed a block" do
it "returns an 'a'-element, using the passed Hash for attributes" do output = @html.a("http://www.example.com") { "Example" }
attributes = {"HREF" => "http://www.example.com", "TARGET" => "_top"} output.should equal_element("A", { "HREF" => "http://www.example.com" }, "Example")
@html.a(attributes).should equal_element("A", attributes) end
end end
it "includes the passed block's return value when passed a block" do describe "when passed a Hash" do
attributes = {"HREF" => "http://www.example.com", "TARGET" => "_top"} it "returns an 'a'-element, using the passed Hash for attributes" do
@html.a(attributes) { "Example" }.should equal_element("A", attributes, "Example") attributes = {"HREF" => "http://www.example.com", "TARGET" => "_top"}
end @html.a(attributes).should equal_element("A", attributes)
end end
describe "when each HTML generation" do it "includes the passed block's return value when passed a block" do
it "returns the doctype declaration for HTML3" do attributes = {"HREF" => "http://www.example.com", "TARGET" => "_top"}
CGISpecs.cgi_new("html3").a.should == %(<A HREF=""></A>) @html.a(attributes) { "Example" }.should equal_element("A", attributes, "Example")
CGISpecs.cgi_new("html3").a { "link text" }.should == %(<A HREF="">link text</A>) end
end end
it "returns the doctype declaration for HTML4" do describe "when each HTML generation" do
CGISpecs.cgi_new("html4").a.should == %(<A HREF=""></A>) it "returns the doctype declaration for HTML3" do
CGISpecs.cgi_new("html4").a { "link text" }.should == %(<A HREF="">link text</A>) CGISpecs.cgi_new("html3").a.should == %(<A HREF=""></A>)
end CGISpecs.cgi_new("html3").a { "link text" }.should == %(<A HREF="">link text</A>)
it "returns the doctype declaration for the Transitional version of HTML4" do end
CGISpecs.cgi_new("html4Tr").a.should == %(<A HREF=""></A>)
CGISpecs.cgi_new("html4Tr").a { "link text" }.should == %(<A HREF="">link text</A>) it "returns the doctype declaration for HTML4" do
CGISpecs.cgi_new("html4").a.should == %(<A HREF=""></A>)
CGISpecs.cgi_new("html4").a { "link text" }.should == %(<A HREF="">link text</A>)
end
it "returns the doctype declaration for the Transitional version of HTML4" do
CGISpecs.cgi_new("html4Tr").a.should == %(<A HREF=""></A>)
CGISpecs.cgi_new("html4Tr").a { "link text" }.should == %(<A HREF="">link text</A>)
end
end end
end end
end end

47
spec/ruby/library/cgi/htmlextension/base_spec.rb
View File

@ -1,33 +1,36 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
describe "CGI::HtmlExtension#base" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@html = CGISpecs.cgi_new require_relative 'fixtures/common'
end
describe "when bassed a String" do describe "CGI::HtmlExtension#base" do
it "returns a 'base'-element, using the passed String as the 'href'-attribute" do before :each do
output = @html.base("http://www.example.com") @html = CGISpecs.cgi_new
output.should equal_element("BASE", {"HREF" => "http://www.example.com"}, nil, not_closed: true)
end end
it "ignores a passed block" do describe "when bassed a String" do
output = @html.base("http://www.example.com") { "Example" } it "returns a 'base'-element, using the passed String as the 'href'-attribute" do
output.should equal_element("BASE", {"HREF" => "http://www.example.com"}, nil, not_closed: true) output = @html.base("http://www.example.com")
end output.should equal_element("BASE", {"HREF" => "http://www.example.com"}, nil, not_closed: true)
end end
describe "when passed a Hash" do it "ignores a passed block" do
it "returns a 'base'-element, using the passed Hash for attributes" do output = @html.base("http://www.example.com") { "Example" }
output = @html.base("HREF" => "http://www.example.com", "ID" => "test") output.should equal_element("BASE", {"HREF" => "http://www.example.com"}, nil, not_closed: true)
output.should equal_element("BASE", {"HREF" => "http://www.example.com", "ID" => "test"}, nil, not_closed: true) end
end end
it "ignores a passed block" do describe "when passed a Hash" do
output = @html.base("HREF" => "http://www.example.com", "ID" => "test") { "Example" } it "returns a 'base'-element, using the passed Hash for attributes" do
output.should equal_element("BASE", {"HREF" => "http://www.example.com", "ID" => "test"}, nil, not_closed: true) output = @html.base("HREF" => "http://www.example.com", "ID" => "test")
output.should equal_element("BASE", {"HREF" => "http://www.example.com", "ID" => "test"}, nil, not_closed: true)
end
it "ignores a passed block" do
output = @html.base("HREF" => "http://www.example.com", "ID" => "test") { "Example" }
output.should equal_element("BASE", {"HREF" => "http://www.example.com", "ID" => "test"}, nil, not_closed: true)
end
end end
end end
end end

47
spec/ruby/library/cgi/htmlextension/blockquote_spec.rb
View File

@ -1,33 +1,36 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
describe "CGI::HtmlExtension#blockquote" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@html = CGISpecs.cgi_new require_relative 'fixtures/common'
end
describe "when passed a String" do describe "CGI::HtmlExtension#blockquote" do
it "returns a 'blockquote'-element, using the passed String for the 'cite'-attribute" do before :each do
output = @html.blockquote("http://www.example.com/quotes/foo.html") @html = CGISpecs.cgi_new
output.should equal_element("BLOCKQUOTE", "CITE" => "http://www.example.com/quotes/foo.html")
end end
it "includes the passed block's return value when passed a block" do describe "when passed a String" do
output = @html.blockquote("http://www.example.com/quotes/foo.html") { "Foo!" } it "returns a 'blockquote'-element, using the passed String for the 'cite'-attribute" do
output.should equal_element("BLOCKQUOTE", { "CITE" => "http://www.example.com/quotes/foo.html" }, "Foo!") output = @html.blockquote("http://www.example.com/quotes/foo.html")
end output.should equal_element("BLOCKQUOTE", "CITE" => "http://www.example.com/quotes/foo.html")
end end
describe "when passed a Hash" do it "includes the passed block's return value when passed a block" do
it "returns a 'blockquote'-element, using the passed Hash for attributes" do output = @html.blockquote("http://www.example.com/quotes/foo.html") { "Foo!" }
output = @html.blockquote("CITE" => "http://www.example.com/quotes/foo.html", "ID" => "test") output.should equal_element("BLOCKQUOTE", { "CITE" => "http://www.example.com/quotes/foo.html" }, "Foo!")
output.should equal_element("BLOCKQUOTE", "CITE" => "http://www.example.com/quotes/foo.html", "ID" => "test") end
end end
it "includes the passed block's return value when passed a block" do describe "when passed a Hash" do
output = @html.blockquote("CITE" => "http://www.example.com/quotes/foo.html", "ID" => "test") { "Foo!" } it "returns a 'blockquote'-element, using the passed Hash for attributes" do
output.should equal_element("BLOCKQUOTE", {"CITE" => "http://www.example.com/quotes/foo.html", "ID" => "test"}, "Foo!") output = @html.blockquote("CITE" => "http://www.example.com/quotes/foo.html", "ID" => "test")
output.should equal_element("BLOCKQUOTE", "CITE" => "http://www.example.com/quotes/foo.html", "ID" => "test")
end
it "includes the passed block's return value when passed a block" do
output = @html.blockquote("CITE" => "http://www.example.com/quotes/foo.html", "ID" => "test") { "Foo!" }
output.should equal_element("BLOCKQUOTE", {"CITE" => "http://www.example.com/quotes/foo.html", "ID" => "test"}, "Foo!")
end
end end
end end
end end

31
spec/ruby/library/cgi/htmlextension/br_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
describe "CGI::HtmlExtension#br" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@html = CGISpecs.cgi_new require_relative 'fixtures/common'
end
describe "when each HTML generation" do describe "CGI::HtmlExtension#br" do
it "returns the doctype declaration for HTML3" do before :each do
CGISpecs.cgi_new("html3").br.should == "<BR>" @html = CGISpecs.cgi_new
end end
it "returns the doctype declaration for HTML4" do describe "when each HTML generation" do
CGISpecs.cgi_new("html4").br.should == "<BR>" it "returns the doctype declaration for HTML3" do
end CGISpecs.cgi_new("html3").br.should == "<BR>"
it "returns the doctype declaration for the Transitional version of HTML4" do end
CGISpecs.cgi_new("html4Tr").br.should == "<BR>"
it "returns the doctype declaration for HTML4" do
CGISpecs.cgi_new("html4").br.should == "<BR>"
end
it "returns the doctype declaration for the Transitional version of HTML4" do
CGISpecs.cgi_new("html4Tr").br.should == "<BR>"
end
end end
end end
end end

47
spec/ruby/library/cgi/htmlextension/caption_spec.rb
View File

@ -1,33 +1,36 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
describe "CGI::HtmlExtension#caption" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@html = CGISpecs.cgi_new require_relative 'fixtures/common'
end
describe "when passed a String" do describe "CGI::HtmlExtension#caption" do
it "returns a 'caption'-element, using the passed String for the 'align'-attribute" do before :each do
output = @html.caption("left") @html = CGISpecs.cgi_new
output.should equal_element("CAPTION", "ALIGN" => "left")
end end
it "includes the passed block's return value when passed a block" do describe "when passed a String" do
output = @html.caption("left") { "Capital Cities" } it "returns a 'caption'-element, using the passed String for the 'align'-attribute" do
output.should equal_element("CAPTION", {"ALIGN" => "left"}, "Capital Cities") output = @html.caption("left")
end output.should equal_element("CAPTION", "ALIGN" => "left")
end end
describe "when passed a Hash" do it "includes the passed block's return value when passed a block" do
it "returns a 'caption'-element, using the passed Hash for attributes" do output = @html.caption("left") { "Capital Cities" }
output = @html.caption("ALIGN" => "left", "ID" => "test") output.should equal_element("CAPTION", {"ALIGN" => "left"}, "Capital Cities")
output.should equal_element("CAPTION", "ALIGN" => "left", "ID" => "test") end
end end
it "includes the passed block's return value when passed a block" do describe "when passed a Hash" do
output = @html.caption("ALIGN" => "left", "ID" => "test") { "Capital Cities" } it "returns a 'caption'-element, using the passed Hash for attributes" do
output.should equal_element("CAPTION", {"ALIGN" => "left", "ID" => "test"}, "Capital Cities") output = @html.caption("ALIGN" => "left", "ID" => "test")
output.should equal_element("CAPTION", "ALIGN" => "left", "ID" => "test")
end
it "includes the passed block's return value when passed a block" do
output = @html.caption("ALIGN" => "left", "ID" => "test") { "Capital Cities" }
output.should equal_element("CAPTION", {"ALIGN" => "left", "ID" => "test"}, "Capital Cities")
end
end end
end end
end end

129
spec/ruby/library/cgi/htmlextension/checkbox_group_spec.rb
View File

@ -1,76 +1,79 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
describe "CGI::HtmlExtension#checkbox_group" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@html = CGISpecs.cgi_new require_relative 'fixtures/common'
end
describe "when passed name, values ..." do describe "CGI::HtmlExtension#checkbox_group" do
it "returns a sequence of 'checkbox'-elements with the passed name and the passed values" do before :each do
output = CGISpecs.split(@html.checkbox_group("test", "foo", "bar", "baz")) @html = CGISpecs.cgi_new
output[0].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "foo"}, "foo", not_closed: true)
output[1].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "bar"}, "bar", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "baz"}, "baz", not_closed: true)
end end
it "allows passing a value inside an Array" do describe "when passed name, values ..." do
output = CGISpecs.split(@html.checkbox_group("test", ["foo"], "bar", ["baz"])) it "returns a sequence of 'checkbox'-elements with the passed name and the passed values" do
output[0].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "foo"}, "foo", not_closed: true) output = CGISpecs.split(@html.checkbox_group("test", "foo", "bar", "baz"))
output[1].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "bar"}, "bar", not_closed: true) output[0].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "foo"}, "foo", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "baz"}, "baz", not_closed: true) output[1].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "bar"}, "bar", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "baz"}, "baz", not_closed: true)
end
it "allows passing a value inside an Array" do
output = CGISpecs.split(@html.checkbox_group("test", ["foo"], "bar", ["baz"]))
output[0].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "foo"}, "foo", not_closed: true)
output[1].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "bar"}, "bar", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "baz"}, "baz", not_closed: true)
end
it "allows passing a value as an Array containing the value and the checked state or a label" do
output = CGISpecs.split(@html.checkbox_group("test", ["foo"], ["bar", true], ["baz", "label for baz"]))
output[0].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "foo"}, "foo", not_closed: true)
output[1].should equal_element("INPUT", {"CHECKED" => true, "NAME" => "test", "TYPE" => "checkbox", "VALUE" => "bar"}, "bar", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "baz"}, "label for baz", not_closed: true)
end
it "allows passing a value as an Array containing the value, a label and the checked state" do
output = CGISpecs.split(@html.checkbox_group("test", ["foo", "label for foo", true], ["bar", "label for bar", false], ["baz", "label for baz", true]))
output[0].should equal_element("INPUT", {"CHECKED" => true, "NAME" => "test", "TYPE" => "checkbox", "VALUE" => "foo"}, "label for foo", not_closed: true)
output[1].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "bar"}, "label for bar", not_closed: true)
output[2].should equal_element("INPUT", {"CHECKED" => true, "NAME" => "test", "TYPE" => "checkbox", "VALUE" => "baz"}, "label for baz", not_closed: true)
end
it "returns an empty String when passed no values" do
@html.checkbox_group("test").should == ""
end
it "ignores a passed block" do
output = CGISpecs.split(@html.checkbox_group("test", "foo", "bar", "baz") { "test" })
output[0].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "foo"}, "foo", not_closed: true)
output[1].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "bar"}, "bar", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "baz"}, "baz", not_closed: true)
end
end end
it "allows passing a value as an Array containing the value and the checked state or a label" do describe "when passed Hash" do
output = CGISpecs.split(@html.checkbox_group("test", ["foo"], ["bar", true], ["baz", "label for baz"])) it "uses the passed Hash to generate the checkbox sequence" do
output[0].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "foo"}, "foo", not_closed: true) output = CGISpecs.split(@html.checkbox_group("NAME" => "name", "VALUES" => ["foo", "bar", "baz"]))
output[1].should equal_element("INPUT", {"CHECKED" => true, "NAME" => "test", "TYPE" => "checkbox", "VALUE" => "bar"}, "bar", not_closed: true) output[0].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "checkbox", "VALUE" => "foo"}, "foo", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "baz"}, "label for baz", not_closed: true) output[1].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "checkbox", "VALUE" => "bar"}, "bar", not_closed: true)
end output[2].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "checkbox", "VALUE" => "baz"}, "baz", not_closed: true)
it "allows passing a value as an Array containing the value, a label and the checked state" do output = CGISpecs.split(@html.checkbox_group("NAME" => "name", "VALUES" => [["foo"], ["bar", true], "baz"]))
output = CGISpecs.split(@html.checkbox_group("test", ["foo", "label for foo", true], ["bar", "label for bar", false], ["baz", "label for baz", true])) output[0].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "checkbox", "VALUE" => "foo"}, "foo", not_closed: true)
output[0].should equal_element("INPUT", {"CHECKED" => true, "NAME" => "test", "TYPE" => "checkbox", "VALUE" => "foo"}, "label for foo", not_closed: true) output[1].should equal_element("INPUT", {"CHECKED" => true, "NAME" => "name", "TYPE" => "checkbox", "VALUE" => "bar"}, "bar", not_closed: true)
output[1].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "bar"}, "label for bar", not_closed: true) output[2].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "checkbox", "VALUE" => "baz"}, "baz", not_closed: true)
output[2].should equal_element("INPUT", {"CHECKED" => true, "NAME" => "test", "TYPE" => "checkbox", "VALUE" => "baz"}, "label for baz", not_closed: true)
end
it "returns an empty String when passed no values" do output = CGISpecs.split(@html.checkbox_group("NAME" => "name", "VALUES" => [["1", "Foo"], ["2", "Bar", true], "Baz"]))
@html.checkbox_group("test").should == "" output[0].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "checkbox", "VALUE" => "1"}, "Foo", not_closed: true)
end output[1].should equal_element("INPUT", {"CHECKED" => true, "NAME" => "name", "TYPE" => "checkbox", "VALUE" => "2"}, "Bar", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "checkbox", "VALUE" => "Baz"}, "Baz", not_closed: true)
end
it "ignores a passed block" do it "ignores a passed block" do
output = CGISpecs.split(@html.checkbox_group("test", "foo", "bar", "baz") { "test" }) output = CGISpecs.split(@html.checkbox_group("NAME" => "name", "VALUES" => ["foo", "bar", "baz"]) { "test" })
output[0].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "foo"}, "foo", not_closed: true) output[0].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "checkbox", "VALUE" => "foo"}, "foo", not_closed: true)
output[1].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "bar"}, "bar", not_closed: true) output[1].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "checkbox", "VALUE" => "bar"}, "bar", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "baz"}, "baz", not_closed: true) output[2].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "checkbox", "VALUE" => "baz"}, "baz", not_closed: true)
end end
end
describe "when passed Hash" do
it "uses the passed Hash to generate the checkbox sequence" do
output = CGISpecs.split(@html.checkbox_group("NAME" => "name", "VALUES" => ["foo", "bar", "baz"]))
output[0].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "checkbox", "VALUE" => "foo"}, "foo", not_closed: true)
output[1].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "checkbox", "VALUE" => "bar"}, "bar", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "checkbox", "VALUE" => "baz"}, "baz", not_closed: true)
output = CGISpecs.split(@html.checkbox_group("NAME" => "name", "VALUES" => [["foo"], ["bar", true], "baz"]))
output[0].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "checkbox", "VALUE" => "foo"}, "foo", not_closed: true)
output[1].should equal_element("INPUT", {"CHECKED" => true, "NAME" => "name", "TYPE" => "checkbox", "VALUE" => "bar"}, "bar", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "checkbox", "VALUE" => "baz"}, "baz", not_closed: true)
output = CGISpecs.split(@html.checkbox_group("NAME" => "name", "VALUES" => [["1", "Foo"], ["2", "Bar", true], "Baz"]))
output[0].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "checkbox", "VALUE" => "1"}, "Foo", not_closed: true)
output[1].should equal_element("INPUT", {"CHECKED" => true, "NAME" => "name", "TYPE" => "checkbox", "VALUE" => "2"}, "Bar", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "checkbox", "VALUE" => "Baz"}, "Baz", not_closed: true)
end
it "ignores a passed block" do
output = CGISpecs.split(@html.checkbox_group("NAME" => "name", "VALUES" => ["foo", "bar", "baz"]) { "test" })
output[0].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "checkbox", "VALUE" => "foo"}, "foo", not_closed: true)
output[1].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "checkbox", "VALUE" => "bar"}, "bar", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "checkbox", "VALUE" => "baz"}, "baz", not_closed: true)
end end
end end
end end

117
spec/ruby/library/cgi/htmlextension/checkbox_spec.rb
View File

@ -1,77 +1,80 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
describe "CGI::HtmlExtension#checkbox" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@html = CGISpecs.cgi_new require_relative 'fixtures/common'
end
describe "when passed no arguments" do describe "CGI::HtmlExtension#checkbox" do
it "returns a checkbox-'input'-element without a name" do before :each do
output = @html.checkbox @html = CGISpecs.cgi_new
output.should equal_element("INPUT", {"NAME" => "", "TYPE" => "checkbox"}, "", not_closed: true)
end end
it "ignores a passed block" do describe "when passed no arguments" do
output = @html.checkbox { "test" } it "returns a checkbox-'input'-element without a name" do
output.should equal_element("INPUT", {"NAME" => "", "TYPE" => "checkbox"}, "", not_closed: true) output = @html.checkbox
end output.should equal_element("INPUT", {"NAME" => "", "TYPE" => "checkbox"}, "", not_closed: true)
end end
describe "when passed name" do it "ignores a passed block" do
it "returns a checkbox-'input'-element with the passed name" do output = @html.checkbox { "test" }
output = @html.checkbox("test") output.should equal_element("INPUT", {"NAME" => "", "TYPE" => "checkbox"}, "", not_closed: true)
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed name" do
output = @html.checkbox("test") { "test" } it "returns a checkbox-'input'-element with the passed name" do
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox"}, "", not_closed: true) output = @html.checkbox("test")
end output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox"}, "", not_closed: true)
end end
describe "CGI::HtmlExtension#checkbox when passed name, value" do it "ignores a passed block" do
it "returns a checkbox-'input'-element with the passed name and value" do output = @html.checkbox("test") { "test" }
output = @html.checkbox("test", "test-value") output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox"}, "", not_closed: true)
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "test-value"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "CGI::HtmlExtension#checkbox when passed name, value" do
output = @html.checkbox("test", "test-value") { "test" } it "returns a checkbox-'input'-element with the passed name and value" do
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "test-value"}, "", not_closed: true) output = @html.checkbox("test", "test-value")
end output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "test-value"}, "", not_closed: true)
end end
describe "when passed name, value, checked" do it "ignores a passed block" do
it "returns a checked checkbox-'input'-element with the passed name and value when checked is true" do output = @html.checkbox("test", "test-value") { "test" }
output = @html.checkbox("test", "test-value", true) output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "test-value"}, "", not_closed: true)
output.should equal_element("INPUT", {"CHECKED" => true, "NAME" => "test", "TYPE" => "checkbox", "VALUE" => "test-value"}, "", not_closed: true) end
output = @html.checkbox("test", "test-value", false)
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "test-value"}, "", not_closed: true)
output = @html.checkbox("test", "test-value", nil)
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "test-value"}, "", not_closed: true)
end end
it "ignores a passed block" do describe "when passed name, value, checked" do
output = @html.checkbox("test", "test-value", nil) { "test" } it "returns a checked checkbox-'input'-element with the passed name and value when checked is true" do
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "test-value"}, "", not_closed: true) output = @html.checkbox("test", "test-value", true)
end output.should equal_element("INPUT", {"CHECKED" => true, "NAME" => "test", "TYPE" => "checkbox", "VALUE" => "test-value"}, "", not_closed: true)
end
describe "when passed Hash" do output = @html.checkbox("test", "test-value", false)
it "returns a checkbox-'input'-element using the passed Hash for attributes" do output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "test-value"}, "", not_closed: true)
attributes = {"NAME" => "test", "VALUE" => "test-value", "CHECKED" => true}
output = @html.checkbox(attributes) output = @html.checkbox("test", "test-value", nil)
output.should equal_element("INPUT", attributes, "", not_closed: true) output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "test-value"}, "", not_closed: true)
end
it "ignores a passed block" do
output = @html.checkbox("test", "test-value", nil) { "test" }
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "checkbox", "VALUE" => "test-value"}, "", not_closed: true)
end
end end
it "ignores a passed block" do describe "when passed Hash" do
attributes = {"NAME" => "test", "VALUE" => "test-value", "CHECKED" => true} it "returns a checkbox-'input'-element using the passed Hash for attributes" do
output = @html.checkbox(attributes) { "test" } attributes = {"NAME" => "test", "VALUE" => "test-value", "CHECKED" => true}
output.should equal_element("INPUT", attributes, "", not_closed: true) output = @html.checkbox(attributes)
output.should equal_element("INPUT", attributes, "", not_closed: true)
end
it "ignores a passed block" do
attributes = {"NAME" => "test", "VALUE" => "test-value", "CHECKED" => true}
output = @html.checkbox(attributes) { "test" }
output.should equal_element("INPUT", attributes, "", not_closed: true)
end
end end
end end
end end

41
spec/ruby/library/cgi/htmlextension/doctype_spec.rb
View File

@ -1,27 +1,30 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
describe "CGI::HtmlExtension#doctype" do ruby_version_is ""..."3.5" do
describe "when each HTML generation" do require 'cgi'
it "returns the doctype declaration for HTML3" do require_relative 'fixtures/common'
expect = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">'
CGISpecs.cgi_new("html3").doctype.should == expect
end
it "returns the doctype declaration for HTML4" do describe "CGI::HtmlExtension#doctype" do
expect = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">' describe "when each HTML generation" do
CGISpecs.cgi_new("html4").doctype.should == expect it "returns the doctype declaration for HTML3" do
end expect = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">'
CGISpecs.cgi_new("html3").doctype.should == expect
end
it "returns the doctype declaration for the Frameset version of HTML4" do it "returns the doctype declaration for HTML4" do
expect = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">' expect = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">'
CGISpecs.cgi_new("html4Fr").doctype.should == expect CGISpecs.cgi_new("html4").doctype.should == expect
end end
it "returns the doctype declaration for the Transitional version of HTML4" do it "returns the doctype declaration for the Frameset version of HTML4" do
expect = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">' expect = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">'
CGISpecs.cgi_new("html4Tr").doctype.should == expect CGISpecs.cgi_new("html4Fr").doctype.should == expect
end
it "returns the doctype declaration for the Transitional version of HTML4" do
expect = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">'
CGISpecs.cgi_new("html4Tr").doctype.should == expect
end
end end
end end
end end

107
spec/ruby/library/cgi/htmlextension/file_field_spec.rb
View File

@ -1,72 +1,75 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
describe "CGI::HtmlExtension#file_field" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@html = CGISpecs.cgi_new require_relative 'fixtures/common'
end
describe "when passed no arguments" do describe "CGI::HtmlExtension#file_field" do
it "returns a file-'input'-element without a name and a size of 20" do before :each do
output = @html.file_field @html = CGISpecs.cgi_new
output.should equal_element("INPUT", {"SIZE" => 20, "NAME" => "", "TYPE" => "file"}, "", not_closed: true)
end end
it "ignores a passed block" do describe "when passed no arguments" do
output = @html.file_field { "test" } it "returns a file-'input'-element without a name and a size of 20" do
output.should equal_element("INPUT", {"SIZE" => 20, "NAME" => "", "TYPE" => "file"}, "", not_closed: true) output = @html.file_field
end output.should equal_element("INPUT", {"SIZE" => 20, "NAME" => "", "TYPE" => "file"}, "", not_closed: true)
end end
describe "when passed name" do it "ignores a passed block" do
it "returns a checkbox-'input'-element with the passed name" do output = @html.file_field { "test" }
output = @html.file_field("Example") output.should equal_element("INPUT", {"SIZE" => 20, "NAME" => "", "TYPE" => "file"}, "", not_closed: true)
output.should equal_element("INPUT", {"SIZE" => 20, "NAME" => "Example", "TYPE" => "file"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed name" do
output = @html.file_field("Example") { "test" } it "returns a checkbox-'input'-element with the passed name" do
output.should equal_element("INPUT", {"SIZE" => 20, "NAME" => "Example", "TYPE" => "file"}, "", not_closed: true) output = @html.file_field("Example")
end output.should equal_element("INPUT", {"SIZE" => 20, "NAME" => "Example", "TYPE" => "file"}, "", not_closed: true)
end end
describe "when passed name, size" do it "ignores a passed block" do
it "returns a checkbox-'input'-element with the passed name and size" do output = @html.file_field("Example") { "test" }
output = @html.file_field("Example", 40) output.should equal_element("INPUT", {"SIZE" => 20, "NAME" => "Example", "TYPE" => "file"}, "", not_closed: true)
output.should equal_element("INPUT", {"SIZE" => 40, "NAME" => "Example", "TYPE" => "file"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed name, size" do
output = @html.file_field("Example", 40) { "test" } it "returns a checkbox-'input'-element with the passed name and size" do
output.should equal_element("INPUT", {"SIZE" => 40, "NAME" => "Example", "TYPE" => "file"}, "", not_closed: true) output = @html.file_field("Example", 40)
end output.should equal_element("INPUT", {"SIZE" => 40, "NAME" => "Example", "TYPE" => "file"}, "", not_closed: true)
end end
describe "when passed name, size, maxlength" do it "ignores a passed block" do
it "returns a checkbox-'input'-element with the passed name, size and maxlength" do output = @html.file_field("Example", 40) { "test" }
output = @html.file_field("Example", 40, 100) output.should equal_element("INPUT", {"SIZE" => 40, "NAME" => "Example", "TYPE" => "file"}, "", not_closed: true)
output.should equal_element("INPUT", {"SIZE" => 40, "NAME" => "Example", "TYPE" => "file", "MAXLENGTH" => 100}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed name, size, maxlength" do
output = @html.file_field("Example", 40, 100) { "test" } it "returns a checkbox-'input'-element with the passed name, size and maxlength" do
output.should equal_element("INPUT", {"SIZE" => 40, "NAME" => "Example", "TYPE" => "file", "MAXLENGTH" => 100}, "", not_closed: true) output = @html.file_field("Example", 40, 100)
end output.should equal_element("INPUT", {"SIZE" => 40, "NAME" => "Example", "TYPE" => "file", "MAXLENGTH" => 100}, "", not_closed: true)
end end
describe "when passed a Hash" do it "ignores a passed block" do
it "returns a file-'input'-element using the passed Hash for attributes" do output = @html.file_field("Example", 40, 100) { "test" }
output = @html.file_field("NAME" => "test", "SIZE" => 40) output.should equal_element("INPUT", {"SIZE" => 40, "NAME" => "Example", "TYPE" => "file", "MAXLENGTH" => 100}, "", not_closed: true)
output.should equal_element("INPUT", {"NAME" => "test", "SIZE" => 40}, "", not_closed: true) end
output = @html.file_field("NAME" => "test", "MAXLENGTH" => 100)
output.should equal_element("INPUT", {"NAME" => "test", "MAXLENGTH" => 100}, "", not_closed: true)
end end
it "ignores a passed block" do describe "when passed a Hash" do
output = @html.file_field("NAME" => "test", "SIZE" => 40) { "test" } it "returns a file-'input'-element using the passed Hash for attributes" do
output.should equal_element("INPUT", {"NAME" => "test", "SIZE" => 40}, "", not_closed: true) output = @html.file_field("NAME" => "test", "SIZE" => 40)
output.should equal_element("INPUT", {"NAME" => "test", "SIZE" => 40}, "", not_closed: true)
output = @html.file_field("NAME" => "test", "MAXLENGTH" => 100)
output.should equal_element("INPUT", {"NAME" => "test", "MAXLENGTH" => 100}, "", not_closed: true)
end
it "ignores a passed block" do
output = @html.file_field("NAME" => "test", "SIZE" => 40) { "test" }
output.should equal_element("INPUT", {"NAME" => "test", "SIZE" => 40}, "", not_closed: true)
end
end end
end end
end end

85
spec/ruby/library/cgi/htmlextension/form_spec.rb
View File

@ -1,58 +1,61 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
describe "CGI::HtmlExtension#form" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@html = CGISpecs.cgi_new require_relative 'fixtures/common'
@html.stub!(:script_name).and_return("/path/to/some/script")
end
describe "when passed no arguments" do describe "CGI::HtmlExtension#form" do
it "returns a 'form'-element" do before :each do
output = @html.form @html = CGISpecs.cgi_new
output.should equal_element("FORM", {"ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "post", "ACTION" => "/path/to/some/script"}, "") @html.stub!(:script_name).and_return("/path/to/some/script")
end end
it "includes the return value of the passed block when passed a block" do describe "when passed no arguments" do
output = @html.form { "test" } it "returns a 'form'-element" do
output.should equal_element("FORM", {"ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "post", "ACTION" => "/path/to/some/script"}, "test") output = @html.form
end output.should equal_element("FORM", {"ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "post", "ACTION" => "/path/to/some/script"}, "")
end end
describe "when passed method" do it "includes the return value of the passed block when passed a block" do
it "returns a 'form'-element with the passed method" do output = @html.form { "test" }
output = @html.form("get") output.should equal_element("FORM", {"ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "post", "ACTION" => "/path/to/some/script"}, "test")
output.should equal_element("FORM", {"ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "get", "ACTION" => "/path/to/some/script"}, "") end
end end
it "includes the return value of the passed block when passed a block" do describe "when passed method" do
output = @html.form("get") { "test" } it "returns a 'form'-element with the passed method" do
output.should equal_element("FORM", {"ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "get", "ACTION" => "/path/to/some/script"}, "test") output = @html.form("get")
end output.should equal_element("FORM", {"ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "get", "ACTION" => "/path/to/some/script"}, "")
end end
describe "when passed method, action" do it "includes the return value of the passed block when passed a block" do
it "returns a 'form'-element with the passed method and the passed action" do output = @html.form("get") { "test" }
output = @html.form("get", "/some/other/script") output.should equal_element("FORM", {"ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "get", "ACTION" => "/path/to/some/script"}, "test")
output.should equal_element("FORM", {"ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "get", "ACTION" => "/some/other/script"}, "") end
end end
it "includes the return value of the passed block when passed a block" do describe "when passed method, action" do
output = @html.form("get", "/some/other/script") { "test" } it "returns a 'form'-element with the passed method and the passed action" do
output.should equal_element("FORM", {"ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "get", "ACTION" => "/some/other/script"}, "test") output = @html.form("get", "/some/other/script")
end output.should equal_element("FORM", {"ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "get", "ACTION" => "/some/other/script"}, "")
end end
describe "when passed method, action, enctype" do it "includes the return value of the passed block when passed a block" do
it "returns a 'form'-element with the passed method, action and enctype" do output = @html.form("get", "/some/other/script") { "test" }
output = @html.form("get", "/some/other/script", "multipart/form-data") output.should equal_element("FORM", {"ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "get", "ACTION" => "/some/other/script"}, "test")
output.should equal_element("FORM", {"ENCTYPE" => "multipart/form-data", "METHOD" => "get", "ACTION" => "/some/other/script"}, "") end
end end
it "includes the return value of the passed block when passed a block" do describe "when passed method, action, enctype" do
output = @html.form("get", "/some/other/script", "multipart/form-data") { "test" } it "returns a 'form'-element with the passed method, action and enctype" do
output.should equal_element("FORM", {"ENCTYPE" => "multipart/form-data", "METHOD" => "get", "ACTION" => "/some/other/script"}, "test") output = @html.form("get", "/some/other/script", "multipart/form-data")
output.should equal_element("FORM", {"ENCTYPE" => "multipart/form-data", "METHOD" => "get", "ACTION" => "/some/other/script"}, "")
end
it "includes the return value of the passed block when passed a block" do
output = @html.form("get", "/some/other/script", "multipart/form-data") { "test" }
output.should equal_element("FORM", {"ENCTYPE" => "multipart/form-data", "METHOD" => "get", "ACTION" => "/some/other/script"}, "test")
end
end end
end end
end end

21
spec/ruby/library/cgi/htmlextension/frame_spec.rb
View File

@ -1,14 +1,17 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require_relative 'fixtures/common'
require 'cgi'
describe "CGI::HtmlExtension#frame" do ruby_version_is ""..."3.5" do
before :each do require_relative 'fixtures/common'
@html = CGISpecs.cgi_new("html4Fr") require 'cgi'
end
it "initializes the HTML Generation methods for the Frameset version of HTML4" do describe "CGI::HtmlExtension#frame" do
@html.frameset.should == "<FRAMESET></FRAMESET>" before :each do
@html.frameset { "link text" }.should == "<FRAMESET>link text</FRAMESET>" @html = CGISpecs.cgi_new("html4Fr")
end
it "initializes the HTML Generation methods for the Frameset version of HTML4" do
@html.frameset.should == "<FRAMESET></FRAMESET>"
@html.frameset { "link text" }.should == "<FRAMESET>link text</FRAMESET>"
end
end end
end end

21
spec/ruby/library/cgi/htmlextension/frameset_spec.rb
View File

@ -1,14 +1,17 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require_relative 'fixtures/common'
require 'cgi'
describe "CGI::HtmlExtension#frameset" do ruby_version_is ""..."3.5" do
before :each do require_relative 'fixtures/common'
@html = CGISpecs.cgi_new("html4Fr") require 'cgi'
end
it "initializes the HTML Generation methods for the Frameset version of HTML4" do describe "CGI::HtmlExtension#frameset" do
@html.frameset.should == "<FRAMESET></FRAMESET>" before :each do
@html.frameset { "link text" }.should == "<FRAMESET>link text</FRAMESET>" @html = CGISpecs.cgi_new("html4Fr")
end
it "initializes the HTML Generation methods for the Frameset version of HTML4" do
@html.frameset.should == "<FRAMESET></FRAMESET>"
@html.frameset { "link text" }.should == "<FRAMESET>link text</FRAMESET>"
end
end end
end end

87
spec/ruby/library/cgi/htmlextension/hidden_spec.rb
View File

@ -1,59 +1,62 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
describe "CGI::HtmlExtension#hidden" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@html = CGISpecs.cgi_new require_relative 'fixtures/common'
end
describe "when passed no arguments" do describe "CGI::HtmlExtension#hidden" do
it "returns an hidden-'input'-element without a name" do before :each do
output = @html.hidden @html = CGISpecs.cgi_new
output.should equal_element("INPUT", {"NAME" => "", "TYPE" => "hidden"}, "", not_closed: true)
end end
it "ignores a passed block" do describe "when passed no arguments" do
output = @html.hidden { "test" } it "returns an hidden-'input'-element without a name" do
output.should equal_element("INPUT", {"NAME" => "", "TYPE" => "hidden"}, "", not_closed: true) output = @html.hidden
end output.should equal_element("INPUT", {"NAME" => "", "TYPE" => "hidden"}, "", not_closed: true)
end end
describe "when passed name" do it "ignores a passed block" do
it "returns an hidden-'input'-element with the passed name" do output = @html.hidden { "test" }
output = @html.hidden("test") output.should equal_element("INPUT", {"NAME" => "", "TYPE" => "hidden"}, "", not_closed: true)
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "hidden"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed name" do
output = @html.hidden("test") { "test" } it "returns an hidden-'input'-element with the passed name" do
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "hidden"}, "", not_closed: true) output = @html.hidden("test")
end output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "hidden"}, "", not_closed: true)
end end
describe "when passed name, value" do it "ignores a passed block" do
it "returns an hidden-'input'-element with the passed name and value" do output = @html.hidden("test") { "test" }
output = @html.hidden("test", "some value") output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "hidden"}, "", not_closed: true)
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "hidden", "VALUE" => "some value"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed name, value" do
output = @html.hidden("test", "some value") { "test" } it "returns an hidden-'input'-element with the passed name and value" do
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "hidden", "VALUE" => "some value"}, "", not_closed: true) output = @html.hidden("test", "some value")
end output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "hidden", "VALUE" => "some value"}, "", not_closed: true)
end end
describe "when passed Hash" do it "ignores a passed block" do
it "returns a checkbox-'input'-element using the passed Hash for attributes" do output = @html.hidden("test", "some value") { "test" }
attributes = { "NAME" => "test", "VALUE" => "some value" } output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "hidden", "VALUE" => "some value"}, "", not_closed: true)
output = @html.hidden("test", "some value") end
output.should equal_element("INPUT", attributes, "", not_closed: true)
end end
it "ignores a passed block" do describe "when passed Hash" do
attributes = { "NAME" => "test", "VALUE" => "some value" } it "returns a checkbox-'input'-element using the passed Hash for attributes" do
output = @html.hidden("test", "some value") { "test" } attributes = { "NAME" => "test", "VALUE" => "some value" }
output.should equal_element("INPUT", attributes, "", not_closed: true) output = @html.hidden("test", "some value")
output.should equal_element("INPUT", attributes, "", not_closed: true)
end
it "ignores a passed block" do
attributes = { "NAME" => "test", "VALUE" => "some value" }
output = @html.hidden("test", "some value") { "test" }
output.should equal_element("INPUT", attributes, "", not_closed: true)
end
end end
end end
end end

99
spec/ruby/library/cgi/htmlextension/html_spec.rb
View File

@ -1,66 +1,69 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
describe "CGI::HtmlExtension#html" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@html = CGISpecs.cgi_new require_relative 'fixtures/common'
@html.stub!(:doctype).and_return("<!DOCTYPE SUPA-FUNKAY-RUBYSPEC-DOCTYPE>")
end
describe "when passed no arguments" do describe "CGI::HtmlExtension#html" do
it "returns a self's doctype and an 'html'-element" do before :each do
expected = '<!DOCTYPE SUPA-FUNKAY-RUBYSPEC-DOCTYPE><HTML>' @html = CGISpecs.cgi_new
@html.html.should == expected @html.stub!(:doctype).and_return("<!DOCTYPE SUPA-FUNKAY-RUBYSPEC-DOCTYPE>")
end end
it "includes the passed block when passed a block" do describe "when passed no arguments" do
expected = '<!DOCTYPE SUPA-FUNKAY-RUBYSPEC-DOCTYPE><HTML>test</HTML>' it "returns a self's doctype and an 'html'-element" do
@html.html { "test" }.should == expected expected = '<!DOCTYPE SUPA-FUNKAY-RUBYSPEC-DOCTYPE><HTML>'
end @html.html.should == expected
end end
describe "when passed 'PRETTY'" do it "includes the passed block when passed a block" do
it "returns pretty output when the passed String is 'PRETTY" do expected = '<!DOCTYPE SUPA-FUNKAY-RUBYSPEC-DOCTYPE><HTML>test</HTML>'
expected = "<!DOCTYPE SUPA-FUNKAY-RUBYSPEC-DOCTYPE>\n<HTML>\n" @html.html { "test" }.should == expected
@html.html("PRETTY").should == expected end
end end
it "includes the passed block when passed a block" do describe "when passed 'PRETTY'" do
expected = "<!DOCTYPE SUPA-FUNKAY-RUBYSPEC-DOCTYPE>\n<HTML>\n test\n</HTML>\n" it "returns pretty output when the passed String is 'PRETTY" do
@html.html("PRETTY") { "test" }.should == expected expected = "<!DOCTYPE SUPA-FUNKAY-RUBYSPEC-DOCTYPE>\n<HTML>\n"
end @html.html("PRETTY").should == expected
end end
describe "when passed a Hash" do it "includes the passed block when passed a block" do
it "returns an 'html'-element using the passed Hash for attributes" do expected = "<!DOCTYPE SUPA-FUNKAY-RUBYSPEC-DOCTYPE>\n<HTML>\n test\n</HTML>\n"
expected = '<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN"><HTML BLA="TEST">' @html.html("PRETTY") { "test" }.should == expected
@html.html("DOCTYPE" => '<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">', "BLA" => "TEST").should == expected end
end end
it "omits the doctype when the Hash contains a 'DOCTYPE' entry that's false or nil" do describe "when passed a Hash" do
@html.html("DOCTYPE" => false).should == "<HTML>" it "returns an 'html'-element using the passed Hash for attributes" do
@html.html("DOCTYPE" => nil).should == "<HTML>" expected = '<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN"><HTML BLA="TEST">'
end @html.html("DOCTYPE" => '<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">', "BLA" => "TEST").should == expected
end end
describe "when each HTML generation" do it "omits the doctype when the Hash contains a 'DOCTYPE' entry that's false or nil" do
it "returns the doctype declaration for HTML3" do @html.html("DOCTYPE" => false).should == "<HTML>"
expect = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">' @html.html("DOCTYPE" => nil).should == "<HTML>"
CGISpecs.cgi_new("html3").html.should == expect + "<HTML>" end
CGISpecs.cgi_new("html3").html { "html body" }.should == expect + "<HTML>html body</HTML>"
end end
it "returns the doctype declaration for HTML4" do describe "when each HTML generation" do
expect = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">' it "returns the doctype declaration for HTML3" do
CGISpecs.cgi_new("html4").html.should == expect + "<HTML>" expect = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">'
CGISpecs.cgi_new("html4").html { "html body" }.should == expect + "<HTML>html body</HTML>" CGISpecs.cgi_new("html3").html.should == expect + "<HTML>"
end CGISpecs.cgi_new("html3").html { "html body" }.should == expect + "<HTML>html body</HTML>"
end
it "returns the doctype declaration for the Transitional version of HTML4" do it "returns the doctype declaration for HTML4" do
expect = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">' expect = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">'
CGISpecs.cgi_new("html4Tr").html.should == expect + "<HTML>" CGISpecs.cgi_new("html4").html.should == expect + "<HTML>"
CGISpecs.cgi_new("html4Tr").html { "html body" }.should == expect + "<HTML>html body</HTML>" CGISpecs.cgi_new("html4").html { "html body" }.should == expect + "<HTML>html body</HTML>"
end
it "returns the doctype declaration for the Transitional version of HTML4" do
expect = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">'
CGISpecs.cgi_new("html4Tr").html.should == expect + "<HTML>"
CGISpecs.cgi_new("html4Tr").html { "html body" }.should == expect + "<HTML>html body</HTML>"
end
end end
end end
end end

101
spec/ruby/library/cgi/htmlextension/image_button_spec.rb
View File

@ -1,69 +1,72 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
describe "CGI::HtmlExtension#image_button" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@html = CGISpecs.cgi_new require_relative 'fixtures/common'
end
describe "when passed no arguments" do describe "CGI::HtmlExtension#image_button" do
it "returns an image-'input'-element without a source image" do before :each do
output = @html.image_button @html = CGISpecs.cgi_new
output.should equal_element("INPUT", {"SRC" => "", "TYPE" => "image"}, "", not_closed: true)
end end
it "ignores a passed block" do describe "when passed no arguments" do
output = @html.image_button { "test" } it "returns an image-'input'-element without a source image" do
output.should equal_element("INPUT", {"SRC" => "", "TYPE" => "image"}, "", not_closed: true) output = @html.image_button
end output.should equal_element("INPUT", {"SRC" => "", "TYPE" => "image"}, "", not_closed: true)
end end
describe "when passed src" do it "ignores a passed block" do
it "returns an image-'input'-element with the passed src" do output = @html.image_button { "test" }
output = @html.image_button("/path/to/image.png") output.should equal_element("INPUT", {"SRC" => "", "TYPE" => "image"}, "", not_closed: true)
output.should equal_element("INPUT", {"SRC" => "/path/to/image.png", "TYPE" => "image"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed src" do
output = @html.image_button("/path/to/image.png") { "test" } it "returns an image-'input'-element with the passed src" do
output.should equal_element("INPUT", {"SRC" => "/path/to/image.png", "TYPE" => "image"}, "", not_closed: true) output = @html.image_button("/path/to/image.png")
end output.should equal_element("INPUT", {"SRC" => "/path/to/image.png", "TYPE" => "image"}, "", not_closed: true)
end end
describe "when passed src, name" do it "ignores a passed block" do
it "returns an image-'input'-element with the passed src and name" do output = @html.image_button("/path/to/image.png") { "test" }
output = @html.image_button("/path/to/image.png", "test") output.should equal_element("INPUT", {"SRC" => "/path/to/image.png", "TYPE" => "image"}, "", not_closed: true)
output.should equal_element("INPUT", {"SRC" => "/path/to/image.png", "TYPE" => "image", "NAME" => "test"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed src, name" do
output = @html.image_button("/path/to/image.png", "test") { "test" } it "returns an image-'input'-element with the passed src and name" do
output.should equal_element("INPUT", {"SRC" => "/path/to/image.png", "TYPE" => "image", "NAME" => "test"}, "", not_closed: true) output = @html.image_button("/path/to/image.png", "test")
end output.should equal_element("INPUT", {"SRC" => "/path/to/image.png", "TYPE" => "image", "NAME" => "test"}, "", not_closed: true)
end end
describe "when passed src, name, alt" do it "ignores a passed block" do
it "returns an image-'input'-element with the passed src, name and alt" do output = @html.image_button("/path/to/image.png", "test") { "test" }
output = @html.image_button("/path/to/image.png", "test", "alternative") output.should equal_element("INPUT", {"SRC" => "/path/to/image.png", "TYPE" => "image", "NAME" => "test"}, "", not_closed: true)
output.should equal_element("INPUT", {"SRC" => "/path/to/image.png", "TYPE" => "image", "NAME" => "test", "ALT" => "alternative"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed src, name, alt" do
output = @html.image_button("/path/to/image.png", "test", "alternative") { "test" } it "returns an image-'input'-element with the passed src, name and alt" do
output.should equal_element("INPUT", {"SRC" => "/path/to/image.png", "TYPE" => "image", "NAME" => "test", "ALT" => "alternative"}, "", not_closed: true) output = @html.image_button("/path/to/image.png", "test", "alternative")
end output.should equal_element("INPUT", {"SRC" => "/path/to/image.png", "TYPE" => "image", "NAME" => "test", "ALT" => "alternative"}, "", not_closed: true)
end end
describe "when passed Hash" do it "ignores a passed block" do
it "returns a image-'input'-element using the passed Hash for attributes" do output = @html.image_button("/path/to/image.png", "test", "alternative") { "test" }
output = @html.image_button("NAME" => "test", "VALUE" => "test-value") output.should equal_element("INPUT", {"SRC" => "/path/to/image.png", "TYPE" => "image", "NAME" => "test", "ALT" => "alternative"}, "", not_closed: true)
output.should equal_element("INPUT", {"SRC" => "", "TYPE" => "image", "NAME" => "test", "VALUE" => "test-value"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed Hash" do
output = @html.image_button("NAME" => "test", "VALUE" => "test-value") { "test" } it "returns a image-'input'-element using the passed Hash for attributes" do
output.should equal_element("INPUT", {"SRC" => "", "TYPE" => "image", "NAME" => "test", "VALUE" => "test-value"}, "", not_closed: true) output = @html.image_button("NAME" => "test", "VALUE" => "test-value")
output.should equal_element("INPUT", {"SRC" => "", "TYPE" => "image", "NAME" => "test", "VALUE" => "test-value"}, "", not_closed: true)
end
it "ignores a passed block" do
output = @html.image_button("NAME" => "test", "VALUE" => "test-value") { "test" }
output.should equal_element("INPUT", {"SRC" => "", "TYPE" => "image", "NAME" => "test", "VALUE" => "test-value"}, "", not_closed: true)
end
end end
end end
end end

123
spec/ruby/library/cgi/htmlextension/img_spec.rb
View File

@ -1,83 +1,86 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
describe "CGI::HtmlExtension#img" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@html = CGISpecs.cgi_new require_relative 'fixtures/common'
end
describe "when passed no arguments" do describe "CGI::HtmlExtension#img" do
it "returns an 'img'-element without an src-url or alt-text" do before :each do
output = @html.img @html = CGISpecs.cgi_new
output.should equal_element("IMG", { "SRC" => "", "ALT" => "" }, "", not_closed: true)
end end
it "ignores a passed block" do describe "when passed no arguments" do
output = @html.img { "test" } it "returns an 'img'-element without an src-url or alt-text" do
output.should equal_element("IMG", { "SRC" => "", "ALT" => "" }, "", not_closed: true) output = @html.img
end output.should equal_element("IMG", { "SRC" => "", "ALT" => "" }, "", not_closed: true)
end end
describe "when passed src" do it "ignores a passed block" do
it "returns an 'img'-element with the passed src-url" do output = @html.img { "test" }
output = @html.img("/path/to/some/image.png") output.should equal_element("IMG", { "SRC" => "", "ALT" => "" }, "", not_closed: true)
output.should equal_element("IMG", { "SRC" => "/path/to/some/image.png", "ALT" => "" }, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed src" do
output = @html.img("/path/to/some/image.png") it "returns an 'img'-element with the passed src-url" do
output.should equal_element("IMG", { "SRC" => "/path/to/some/image.png", "ALT" => "" }, "", not_closed: true) output = @html.img("/path/to/some/image.png")
end output.should equal_element("IMG", { "SRC" => "/path/to/some/image.png", "ALT" => "" }, "", not_closed: true)
end end
describe "when passed src, alt" do it "ignores a passed block" do
it "returns an 'img'-element with the passed src-url and the passed alt-text" do output = @html.img("/path/to/some/image.png")
output = @html.img("/path/to/some/image.png", "Alternative") output.should equal_element("IMG", { "SRC" => "/path/to/some/image.png", "ALT" => "" }, "", not_closed: true)
output.should equal_element("IMG", { "SRC" => "/path/to/some/image.png", "ALT" => "Alternative" }, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed src, alt" do
output = @html.img("/path/to/some/image.png", "Alternative") { "test" } it "returns an 'img'-element with the passed src-url and the passed alt-text" do
output.should equal_element("IMG", { "SRC" => "/path/to/some/image.png", "ALT" => "Alternative" }, "", not_closed: true) output = @html.img("/path/to/some/image.png", "Alternative")
end output.should equal_element("IMG", { "SRC" => "/path/to/some/image.png", "ALT" => "Alternative" }, "", not_closed: true)
end end
describe "when passed src, alt, width" do it "ignores a passed block" do
it "returns an 'img'-element with the passed src-url, the passed alt-text and the passed width" do output = @html.img("/path/to/some/image.png", "Alternative") { "test" }
output = @html.img("/path/to/some/image.png", "Alternative", 40) output.should equal_element("IMG", { "SRC" => "/path/to/some/image.png", "ALT" => "Alternative" }, "", not_closed: true)
output.should equal_element("IMG", { "SRC" => "/path/to/some/image.png", "ALT" => "Alternative", "WIDTH" => "40" }, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed src, alt, width" do
output = @html.img("/path/to/some/image.png", "Alternative", 40) { "test" } it "returns an 'img'-element with the passed src-url, the passed alt-text and the passed width" do
output.should equal_element("IMG", { "SRC" => "/path/to/some/image.png", "ALT" => "Alternative", "WIDTH" => "40" }, "", not_closed: true) output = @html.img("/path/to/some/image.png", "Alternative", 40)
end output.should equal_element("IMG", { "SRC" => "/path/to/some/image.png", "ALT" => "Alternative", "WIDTH" => "40" }, "", not_closed: true)
end end
describe "when passed src, alt, width, height" do it "ignores a passed block" do
it "returns an 'img'-element with the passed src-url, the passed alt-text, the passed width and the passed height" do output = @html.img("/path/to/some/image.png", "Alternative", 40) { "test" }
output = @html.img("/path/to/some/image.png", "Alternative", 40, 60) output.should equal_element("IMG", { "SRC" => "/path/to/some/image.png", "ALT" => "Alternative", "WIDTH" => "40" }, "", not_closed: true)
output.should equal_element("IMG", { "SRC" => "/path/to/some/image.png", "ALT" => "Alternative", "WIDTH" => "40", "HEIGHT" => "60" }, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed src, alt, width, height" do
output = @html.img { "test" } it "returns an 'img'-element with the passed src-url, the passed alt-text, the passed width and the passed height" do
output.should equal_element("IMG", { "SRC" => "", "ALT" => "" }, "", not_closed: true) output = @html.img("/path/to/some/image.png", "Alternative", 40, 60)
end output.should equal_element("IMG", { "SRC" => "/path/to/some/image.png", "ALT" => "Alternative", "WIDTH" => "40", "HEIGHT" => "60" }, "", not_closed: true)
end end
describe "when passed Hash" do it "ignores a passed block" do
it "returns an 'img'-element with the passed Hash as attributes" do output = @html.img { "test" }
attributes = { "SRC" => "src", "ALT" => "alt", "WIDTH" => 100, "HEIGHT" => 50 } output.should equal_element("IMG", { "SRC" => "", "ALT" => "" }, "", not_closed: true)
output = @html.img(attributes) end
output.should equal_element("IMG", attributes, "", not_closed: true)
end end
it "ignores a passed block" do describe "when passed Hash" do
attributes = { "SRC" => "src", "ALT" => "alt", "WIDTH" => 100, "HEIGHT" => 50 } it "returns an 'img'-element with the passed Hash as attributes" do
output = @html.img(attributes) { "test" } attributes = { "SRC" => "src", "ALT" => "alt", "WIDTH" => 100, "HEIGHT" => 50 }
output.should equal_element("IMG", attributes, "", not_closed: true) output = @html.img(attributes)
output.should equal_element("IMG", attributes, "", not_closed: true)
end
it "ignores a passed block" do
attributes = { "SRC" => "src", "ALT" => "alt", "WIDTH" => 100, "HEIGHT" => 50 }
output = @html.img(attributes) { "test" }
output.should equal_element("IMG", attributes, "", not_closed: true)
end
end end
end end
end end

95
spec/ruby/library/cgi/htmlextension/multipart_form_spec.rb
View File

@ -1,64 +1,67 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
describe "CGI::HtmlExtension#multipart_form" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@html = CGISpecs.cgi_new require_relative 'fixtures/common'
@html.stub!(:script_name).and_return("/path/to/some/script.rb")
end
describe "when passed no arguments" do describe "CGI::HtmlExtension#multipart_form" do
it "returns a 'form'-element with it's enctype set to multipart" do before :each do
output = @html.multipart_form @html = CGISpecs.cgi_new
output.should equal_element("FORM", { "ENCTYPE" => "multipart/form-data", "METHOD" => "post" }, "") @html.stub!(:script_name).and_return("/path/to/some/script.rb")
end end
it "includes the return value of the passed block when passed a block" do describe "when passed no arguments" do
output = @html.multipart_form { "test" } it "returns a 'form'-element with it's enctype set to multipart" do
output.should equal_element("FORM", { "ENCTYPE" => "multipart/form-data", "METHOD" => "post" }, "test") output = @html.multipart_form
end output.should equal_element("FORM", { "ENCTYPE" => "multipart/form-data", "METHOD" => "post" }, "")
end end
describe "when passed action" do it "includes the return value of the passed block when passed a block" do
it "returns a 'form'-element with the passed action" do output = @html.multipart_form { "test" }
output = @html.multipart_form("/some/other/script.rb") output.should equal_element("FORM", { "ENCTYPE" => "multipart/form-data", "METHOD" => "post" }, "test")
output.should equal_element("FORM", { "ENCTYPE" => "multipart/form-data", "METHOD" => "post", "ACTION" => "/some/other/script.rb" }, "") end
end end
it "includes the return value of the passed block when passed a block" do describe "when passed action" do
output = @html.multipart_form("/some/other/script.rb") { "test" } it "returns a 'form'-element with the passed action" do
output.should equal_element("FORM", { "ENCTYPE" => "multipart/form-data", "METHOD" => "post", "ACTION" => "/some/other/script.rb" }, "test") output = @html.multipart_form("/some/other/script.rb")
end output.should equal_element("FORM", { "ENCTYPE" => "multipart/form-data", "METHOD" => "post", "ACTION" => "/some/other/script.rb" }, "")
end end
describe "when passed action, enctype" do it "includes the return value of the passed block when passed a block" do
it "returns a 'form'-element with the passed action and enctype" do output = @html.multipart_form("/some/other/script.rb") { "test" }
output = @html.multipart_form("/some/other/script.rb", "application/x-www-form-urlencoded") output.should equal_element("FORM", { "ENCTYPE" => "multipart/form-data", "METHOD" => "post", "ACTION" => "/some/other/script.rb" }, "test")
output.should equal_element("FORM", { "ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "post", "ACTION" => "/some/other/script.rb" }, "") end
end end
it "includes the return value of the passed block when passed a block" do describe "when passed action, enctype" do
output = @html.multipart_form("/some/other/script.rb", "application/x-www-form-urlencoded") { "test" } it "returns a 'form'-element with the passed action and enctype" do
output.should equal_element("FORM", { "ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "post", "ACTION" => "/some/other/script.rb" }, "test") output = @html.multipart_form("/some/other/script.rb", "application/x-www-form-urlencoded")
end output.should equal_element("FORM", { "ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "post", "ACTION" => "/some/other/script.rb" }, "")
end end
describe "when passed Hash" do it "includes the return value of the passed block when passed a block" do
it "returns a 'form'-element with the passed Hash as attributes" do output = @html.multipart_form("/some/other/script.rb", "application/x-www-form-urlencoded") { "test" }
output = @html.multipart_form("ID" => "test") output.should equal_element("FORM", { "ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "post", "ACTION" => "/some/other/script.rb" }, "test")
output.should equal_element("FORM", { "ENCTYPE" => "multipart/form-data", "METHOD" => "post", "ID" => "test" }, "") end
output = @html.multipart_form("ID" => "test", "ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "get")
output.should equal_element("FORM", { "ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "get", "ID" => "test" }, "")
end end
it "includes the return value of the passed block when passed a block" do describe "when passed Hash" do
output = @html.multipart_form("ID" => "test") { "test" } it "returns a 'form'-element with the passed Hash as attributes" do
output.should equal_element("FORM", { "ENCTYPE" => "multipart/form-data", "METHOD" => "post", "ID" => "test" }, "test") output = @html.multipart_form("ID" => "test")
output.should equal_element("FORM", { "ENCTYPE" => "multipart/form-data", "METHOD" => "post", "ID" => "test" }, "")
output = @html.multipart_form("ID" => "test", "ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "get") { "test" } output = @html.multipart_form("ID" => "test", "ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "get")
output.should equal_element("FORM", { "ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "get", "ID" => "test" }, "test") output.should equal_element("FORM", { "ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "get", "ID" => "test" }, "")
end
it "includes the return value of the passed block when passed a block" do
output = @html.multipart_form("ID" => "test") { "test" }
output.should equal_element("FORM", { "ENCTYPE" => "multipart/form-data", "METHOD" => "post", "ID" => "test" }, "test")
output = @html.multipart_form("ID" => "test", "ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "get") { "test" }
output.should equal_element("FORM", { "ENCTYPE" => "application/x-www-form-urlencoded", "METHOD" => "get", "ID" => "test" }, "test")
end
end end
end end
end end

125
spec/ruby/library/cgi/htmlextension/password_field_spec.rb
View File

@ -1,84 +1,87 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
describe "CGI::HtmlExtension#password_field" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@html = CGISpecs.cgi_new require_relative 'fixtures/common'
end
describe "when passed no arguments" do describe "CGI::HtmlExtension#password_field" do
it "returns an password-'input'-element without a name" do before :each do
output = @html.password_field @html = CGISpecs.cgi_new
output.should equal_element("INPUT", {"NAME" => "", "TYPE" => "password", "SIZE" => "40"}, "", not_closed: true)
end end
it "ignores a passed block" do describe "when passed no arguments" do
output = @html.password_field { "test" } it "returns an password-'input'-element without a name" do
output.should equal_element("INPUT", {"NAME" => "", "TYPE" => "password", "SIZE" => "40"}, "", not_closed: true) output = @html.password_field
end output.should equal_element("INPUT", {"NAME" => "", "TYPE" => "password", "SIZE" => "40"}, "", not_closed: true)
end end
describe "when passed name" do it "ignores a passed block" do
it "returns an password-'input'-element with the passed name" do output = @html.password_field { "test" }
output = @html.password_field("test") output.should equal_element("INPUT", {"NAME" => "", "TYPE" => "password", "SIZE" => "40"}, "", not_closed: true)
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "password", "SIZE" => "40"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed name" do
output = @html.password_field("test") { "test" } it "returns an password-'input'-element with the passed name" do
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "password", "SIZE" => "40"}, "", not_closed: true) output = @html.password_field("test")
end output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "password", "SIZE" => "40"}, "", not_closed: true)
end end
describe "when passed name, value" do it "ignores a passed block" do
it "returns an password-'input'-element with the passed name and value" do output = @html.password_field("test") { "test" }
output = @html.password_field("test", "some value") output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "password", "SIZE" => "40"}, "", not_closed: true)
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "password", "VALUE" => "some value", "SIZE" => "40"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed name, value" do
output = @html.password_field("test", "some value") { "test" } it "returns an password-'input'-element with the passed name and value" do
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "password", "VALUE" => "some value", "SIZE" => "40"}, "", not_closed: true) output = @html.password_field("test", "some value")
end output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "password", "VALUE" => "some value", "SIZE" => "40"}, "", not_closed: true)
end end
describe "when passed name, value, size" do it "ignores a passed block" do
it "returns an password-'input'-element with the passed name, value and size" do output = @html.password_field("test", "some value") { "test" }
output = @html.password_field("test", "some value", 60) output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "password", "VALUE" => "some value", "SIZE" => "40"}, "", not_closed: true)
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "password", "VALUE" => "some value", "SIZE" => "60"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed name, value, size" do
output = @html.password_field("test", "some value", 60) { "test" } it "returns an password-'input'-element with the passed name, value and size" do
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "password", "VALUE" => "some value", "SIZE" => "60"}, "", not_closed: true) output = @html.password_field("test", "some value", 60)
end output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "password", "VALUE" => "some value", "SIZE" => "60"}, "", not_closed: true)
end end
describe "when passed name, value, size, maxlength" do it "ignores a passed block" do
it "returns an password-'input'-element with the passed name, value, size and maxlength" do output = @html.password_field("test", "some value", 60) { "test" }
output = @html.password_field("test", "some value", 60, 12) output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "password", "VALUE" => "some value", "SIZE" => "60"}, "", not_closed: true)
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "password", "VALUE" => "some value", "SIZE" => "60", "MAXLENGTH" => 12}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed name, value, size, maxlength" do
output = @html.password_field("test", "some value", 60, 12) { "test" } it "returns an password-'input'-element with the passed name, value, size and maxlength" do
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "password", "VALUE" => "some value", "SIZE" => "60", "MAXLENGTH" => 12}, "", not_closed: true) output = @html.password_field("test", "some value", 60, 12)
end output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "password", "VALUE" => "some value", "SIZE" => "60", "MAXLENGTH" => 12}, "", not_closed: true)
end end
describe "when passed Hash" do it "ignores a passed block" do
it "returns a checkbox-'input'-element using the passed Hash for attributes" do output = @html.password_field("test", "some value", 60, 12) { "test" }
output = @html.password_field("NAME" => "test", "VALUE" => "some value") output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "password", "VALUE" => "some value", "SIZE" => "60", "MAXLENGTH" => 12}, "", not_closed: true)
output.should equal_element("INPUT", { "NAME" => "test", "VALUE" => "some value", "TYPE" => "password" }, "", not_closed: true) end
output = @html.password_field("TYPE" => "hidden")
output.should equal_element("INPUT", {"TYPE" => "password"}, "", not_closed: true)
end end
it "ignores a passed block" do describe "when passed Hash" do
output = @html.password_field("NAME" => "test", "VALUE" => "some value") { "test" } it "returns a checkbox-'input'-element using the passed Hash for attributes" do
output.should equal_element("INPUT", { "NAME" => "test", "VALUE" => "some value", "TYPE" => "password" }, "", not_closed: true) output = @html.password_field("NAME" => "test", "VALUE" => "some value")
output.should equal_element("INPUT", { "NAME" => "test", "VALUE" => "some value", "TYPE" => "password" }, "", not_closed: true)
output = @html.password_field("TYPE" => "hidden")
output.should equal_element("INPUT", {"TYPE" => "password"}, "", not_closed: true)
end
it "ignores a passed block" do
output = @html.password_field("NAME" => "test", "VALUE" => "some value") { "test" }
output.should equal_element("INPUT", { "NAME" => "test", "VALUE" => "some value", "TYPE" => "password" }, "", not_closed: true)
end
end end
end end
end end

13
spec/ruby/library/cgi/htmlextension/popup_menu_spec.rb
View File

@ -1,8 +1,11 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
require_relative 'shared/popup_menu'
describe "CGI::HtmlExtension#popup_menu" do ruby_version_is ""..."3.5" do
it_behaves_like :cgi_htmlextension_popup_menu, :popup_menu require 'cgi'
require_relative 'fixtures/common'
require_relative 'shared/popup_menu'
describe "CGI::HtmlExtension#popup_menu" do
it_behaves_like :cgi_htmlextension_popup_menu, :popup_menu
end
end end

117
spec/ruby/library/cgi/htmlextension/radio_button_spec.rb
View File

@ -1,77 +1,80 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
describe "CGI::HtmlExtension#radio_button" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@html = CGISpecs.cgi_new require_relative 'fixtures/common'
end
describe "when passed no arguments" do describe "CGI::HtmlExtension#radio_button" do
it "returns a radio-'input'-element without a name" do before :each do
output = @html.radio_button @html = CGISpecs.cgi_new
output.should equal_element("INPUT", {"NAME" => "", "TYPE" => "radio"}, "", not_closed: true)
end end
it "ignores a passed block" do describe "when passed no arguments" do
output = @html.radio_button { "test" } it "returns a radio-'input'-element without a name" do
output.should equal_element("INPUT", {"NAME" => "", "TYPE" => "radio"}, "", not_closed: true) output = @html.radio_button
end output.should equal_element("INPUT", {"NAME" => "", "TYPE" => "radio"}, "", not_closed: true)
end end
describe "when passed name" do it "ignores a passed block" do
it "returns a radio-'input'-element with the passed name" do output = @html.radio_button { "test" }
output = @html.radio_button("test") output.should equal_element("INPUT", {"NAME" => "", "TYPE" => "radio"}, "", not_closed: true)
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed name" do
output = @html.radio_button("test") { "test" } it "returns a radio-'input'-element with the passed name" do
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio"}, "", not_closed: true) output = @html.radio_button("test")
end output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio"}, "", not_closed: true)
end end
describe "CGI::HtmlExtension#checkbox when passed name, value" do it "ignores a passed block" do
it "returns a radio-'input'-element with the passed name and value" do output = @html.radio_button("test") { "test" }
output = @html.radio_button("test", "test-value") output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio"}, "", not_closed: true)
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "test-value"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "CGI::HtmlExtension#checkbox when passed name, value" do
output = @html.radio_button("test", "test-value") { "test" } it "returns a radio-'input'-element with the passed name and value" do
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "test-value"}, "", not_closed: true) output = @html.radio_button("test", "test-value")
end output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "test-value"}, "", not_closed: true)
end end
describe "when passed name, value, checked" do it "ignores a passed block" do
it "returns a checked radio-'input'-element with the passed name and value when checked is true" do output = @html.radio_button("test", "test-value") { "test" }
output = @html.radio_button("test", "test-value", true) output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "test-value"}, "", not_closed: true)
output.should equal_element("INPUT", {"CHECKED" => true, "NAME" => "test", "TYPE" => "radio", "VALUE" => "test-value"}, "", not_closed: true) end
output = @html.radio_button("test", "test-value", false)
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "test-value"}, "", not_closed: true)
output = @html.radio_button("test", "test-value", nil)
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "test-value"}, "", not_closed: true)
end end
it "ignores a passed block" do describe "when passed name, value, checked" do
output = @html.radio_button("test", "test-value", nil) { "test" } it "returns a checked radio-'input'-element with the passed name and value when checked is true" do
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "test-value"}, "", not_closed: true) output = @html.radio_button("test", "test-value", true)
end output.should equal_element("INPUT", {"CHECKED" => true, "NAME" => "test", "TYPE" => "radio", "VALUE" => "test-value"}, "", not_closed: true)
end
describe "when passed Hash" do output = @html.radio_button("test", "test-value", false)
it "returns a radio-'input'-element using the passed Hash for attributes" do output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "test-value"}, "", not_closed: true)
attributes = {"NAME" => "test", "VALUE" => "test-value", "CHECKED" => true}
output = @html.radio_button(attributes) output = @html.radio_button("test", "test-value", nil)
output.should equal_element("INPUT", attributes, "", not_closed: true) output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "test-value"}, "", not_closed: true)
end
it "ignores a passed block" do
output = @html.radio_button("test", "test-value", nil) { "test" }
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "test-value"}, "", not_closed: true)
end
end end
it "ignores a passed block" do describe "when passed Hash" do
attributes = {"NAME" => "test", "VALUE" => "test-value", "CHECKED" => true} it "returns a radio-'input'-element using the passed Hash for attributes" do
output = @html.radio_button(attributes) { "test" } attributes = {"NAME" => "test", "VALUE" => "test-value", "CHECKED" => true}
output.should equal_element("INPUT", attributes, "", not_closed: true) output = @html.radio_button(attributes)
output.should equal_element("INPUT", attributes, "", not_closed: true)
end
it "ignores a passed block" do
attributes = {"NAME" => "test", "VALUE" => "test-value", "CHECKED" => true}
output = @html.radio_button(attributes) { "test" }
output.should equal_element("INPUT", attributes, "", not_closed: true)
end
end end
end end
end end

131
spec/ruby/library/cgi/htmlextension/radio_group_spec.rb
View File

@ -1,77 +1,80 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
describe "CGI::HtmlExtension#radio_group" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@html = CGISpecs.cgi_new require_relative 'fixtures/common'
end
describe "when passed name, values ..." do describe "CGI::HtmlExtension#radio_group" do
it "returns a sequence of 'radio'-elements with the passed name and the passed values" do before :each do
output = CGISpecs.split(@html.radio_group("test", "foo", "bar", "baz")) @html = CGISpecs.cgi_new
output[0].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "foo"}, "foo", not_closed: true)
output[1].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "bar"}, "bar", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "baz"}, "baz", not_closed: true)
end end
it "allows passing a value inside an Array" do describe "when passed name, values ..." do
output = CGISpecs.split(@html.radio_group("test", ["foo"], "bar", ["baz"])) it "returns a sequence of 'radio'-elements with the passed name and the passed values" do
output[0].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "foo"}, "foo", not_closed: true) output = CGISpecs.split(@html.radio_group("test", "foo", "bar", "baz"))
output[1].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "bar"}, "bar", not_closed: true) output[0].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "foo"}, "foo", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "baz"}, "baz", not_closed: true) output[1].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "bar"}, "bar", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "baz"}, "baz", not_closed: true)
end
it "allows passing a value inside an Array" do
output = CGISpecs.split(@html.radio_group("test", ["foo"], "bar", ["baz"]))
output[0].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "foo"}, "foo", not_closed: true)
output[1].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "bar"}, "bar", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "baz"}, "baz", not_closed: true)
end
it "allows passing a value as an Array containing the value and the checked state or a label" do
output = CGISpecs.split(@html.radio_group("test", ["foo"], ["bar", true], ["baz", "label for baz"]))
output[0].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "foo"}, "foo", not_closed: true)
output[1].should equal_element("INPUT", {"CHECKED" => true, "NAME" => "test", "TYPE" => "radio", "VALUE" => "bar"}, "bar", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "baz"}, "label for baz", not_closed: true)
end
# TODO: CGI does not like passing false instead of true.
it "allows passing a value as an Array containing the value, a label and the checked state" do
output = CGISpecs.split(@html.radio_group("test", ["foo", "label for foo", true], ["bar", "label for bar", false], ["baz", "label for baz", true]))
output[0].should equal_element("INPUT", {"CHECKED" => true, "NAME" => "test", "TYPE" => "radio", "VALUE" => "foo"}, "label for foo", not_closed: true)
output[1].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "bar"}, "label for bar", not_closed: true)
output[2].should equal_element("INPUT", {"CHECKED" => true, "NAME" => "test", "TYPE" => "radio", "VALUE" => "baz"}, "label for baz", not_closed: true)
end
it "returns an empty String when passed no values" do
@html.radio_group("test").should == ""
end
it "ignores a passed block" do
output = CGISpecs.split(@html.radio_group("test", "foo", "bar", "baz") { "test" })
output[0].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "foo"}, "foo", not_closed: true)
output[1].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "bar"}, "bar", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "baz"}, "baz", not_closed: true)
end
end end
it "allows passing a value as an Array containing the value and the checked state or a label" do describe "when passed Hash" do
output = CGISpecs.split(@html.radio_group("test", ["foo"], ["bar", true], ["baz", "label for baz"])) it "uses the passed Hash to generate the radio sequence" do
output[0].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "foo"}, "foo", not_closed: true) output = CGISpecs.split(@html.radio_group("NAME" => "name", "VALUES" => ["foo", "bar", "baz"]))
output[1].should equal_element("INPUT", {"CHECKED" => true, "NAME" => "test", "TYPE" => "radio", "VALUE" => "bar"}, "bar", not_closed: true) output[0].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "radio", "VALUE" => "foo"}, "foo", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "baz"}, "label for baz", not_closed: true) output[1].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "radio", "VALUE" => "bar"}, "bar", not_closed: true)
end output[2].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "radio", "VALUE" => "baz"}, "baz", not_closed: true)
# TODO: CGI does not like passing false instead of true. output = CGISpecs.split(@html.radio_group("NAME" => "name", "VALUES" => [["foo"], ["bar", true], "baz"]))
it "allows passing a value as an Array containing the value, a label and the checked state" do output[0].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "radio", "VALUE" => "foo"}, "foo", not_closed: true)
output = CGISpecs.split(@html.radio_group("test", ["foo", "label for foo", true], ["bar", "label for bar", false], ["baz", "label for baz", true])) output[1].should equal_element("INPUT", {"CHECKED" => true, "NAME" => "name", "TYPE" => "radio", "VALUE" => "bar"}, "bar", not_closed: true)
output[0].should equal_element("INPUT", {"CHECKED" => true, "NAME" => "test", "TYPE" => "radio", "VALUE" => "foo"}, "label for foo", not_closed: true) output[2].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "radio", "VALUE" => "baz"}, "baz", not_closed: true)
output[1].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "bar"}, "label for bar", not_closed: true)
output[2].should equal_element("INPUT", {"CHECKED" => true, "NAME" => "test", "TYPE" => "radio", "VALUE" => "baz"}, "label for baz", not_closed: true)
end
it "returns an empty String when passed no values" do output = CGISpecs.split(@html.radio_group("NAME" => "name", "VALUES" => [["1", "Foo"], ["2", "Bar", true], "Baz"]))
@html.radio_group("test").should == "" output[0].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "radio", "VALUE" => "1"}, "Foo", not_closed: true)
end output[1].should equal_element("INPUT", {"CHECKED" => true, "NAME" => "name", "TYPE" => "radio", "VALUE" => "2"}, "Bar", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "radio", "VALUE" => "Baz"}, "Baz", not_closed: true)
end
it "ignores a passed block" do it "ignores a passed block" do
output = CGISpecs.split(@html.radio_group("test", "foo", "bar", "baz") { "test" }) output = CGISpecs.split(@html.radio_group("NAME" => "name", "VALUES" => ["foo", "bar", "baz"]) { "test" })
output[0].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "foo"}, "foo", not_closed: true) output[0].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "radio", "VALUE" => "foo"}, "foo", not_closed: true)
output[1].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "bar"}, "bar", not_closed: true) output[1].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "radio", "VALUE" => "bar"}, "bar", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "test", "TYPE" => "radio", "VALUE" => "baz"}, "baz", not_closed: true) output[2].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "radio", "VALUE" => "baz"}, "baz", not_closed: true)
end end
end
describe "when passed Hash" do
it "uses the passed Hash to generate the radio sequence" do
output = CGISpecs.split(@html.radio_group("NAME" => "name", "VALUES" => ["foo", "bar", "baz"]))
output[0].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "radio", "VALUE" => "foo"}, "foo", not_closed: true)
output[1].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "radio", "VALUE" => "bar"}, "bar", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "radio", "VALUE" => "baz"}, "baz", not_closed: true)
output = CGISpecs.split(@html.radio_group("NAME" => "name", "VALUES" => [["foo"], ["bar", true], "baz"]))
output[0].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "radio", "VALUE" => "foo"}, "foo", not_closed: true)
output[1].should equal_element("INPUT", {"CHECKED" => true, "NAME" => "name", "TYPE" => "radio", "VALUE" => "bar"}, "bar", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "radio", "VALUE" => "baz"}, "baz", not_closed: true)
output = CGISpecs.split(@html.radio_group("NAME" => "name", "VALUES" => [["1", "Foo"], ["2", "Bar", true], "Baz"]))
output[0].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "radio", "VALUE" => "1"}, "Foo", not_closed: true)
output[1].should equal_element("INPUT", {"CHECKED" => true, "NAME" => "name", "TYPE" => "radio", "VALUE" => "2"}, "Bar", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "radio", "VALUE" => "Baz"}, "Baz", not_closed: true)
end
it "ignores a passed block" do
output = CGISpecs.split(@html.radio_group("NAME" => "name", "VALUES" => ["foo", "bar", "baz"]) { "test" })
output[0].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "radio", "VALUE" => "foo"}, "foo", not_closed: true)
output[1].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "radio", "VALUE" => "bar"}, "bar", not_closed: true)
output[2].should equal_element("INPUT", {"NAME" => "name", "TYPE" => "radio", "VALUE" => "baz"}, "baz", not_closed: true)
end end
end end
end end

83
spec/ruby/library/cgi/htmlextension/reset_spec.rb
View File

@ -1,57 +1,60 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
describe "CGI::HtmlExtension#reset" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@html = CGISpecs.cgi_new require_relative 'fixtures/common'
end
describe "when passed no arguments" do describe "CGI::HtmlExtension#reset" do
it "returns a reset-'input'-element" do before :each do
output = @html.reset @html = CGISpecs.cgi_new
output.should equal_element("INPUT", {"TYPE" => "reset"}, "", not_closed: true)
end end
it "ignores a passed block" do describe "when passed no arguments" do
output = @html.reset { "test" } it "returns a reset-'input'-element" do
output.should equal_element("INPUT", {"TYPE" => "reset"}, "", not_closed: true) output = @html.reset
end output.should equal_element("INPUT", {"TYPE" => "reset"}, "", not_closed: true)
end end
describe "when passed value" do it "ignores a passed block" do
it "returns a reset-'input'-element with the passed value" do output = @html.reset { "test" }
output = @html.reset("Example") output.should equal_element("INPUT", {"TYPE" => "reset"}, "", not_closed: true)
output.should equal_element("INPUT", {"TYPE" => "reset", "VALUE" => "Example"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed value" do
output = @html.reset("Example") { "test" } it "returns a reset-'input'-element with the passed value" do
output.should equal_element("INPUT", {"TYPE" => "reset", "VALUE" => "Example"}, "", not_closed: true) output = @html.reset("Example")
end output.should equal_element("INPUT", {"TYPE" => "reset", "VALUE" => "Example"}, "", not_closed: true)
end end
describe "when passed value, name" do it "ignores a passed block" do
it "returns a reset-'input'-element with the passed value and the passed name" do output = @html.reset("Example") { "test" }
output = @html.reset("Example", "test-name") output.should equal_element("INPUT", {"TYPE" => "reset", "VALUE" => "Example"}, "", not_closed: true)
output.should equal_element("INPUT", {"TYPE" => "reset", "VALUE" => "Example", "NAME" => "test-name"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed value, name" do
output = @html.reset("Example", "test-name") { "test" } it "returns a reset-'input'-element with the passed value and the passed name" do
output.should equal_element("INPUT", {"TYPE" => "reset", "VALUE" => "Example", "NAME" => "test-name"}, "", not_closed: true) output = @html.reset("Example", "test-name")
end output.should equal_element("INPUT", {"TYPE" => "reset", "VALUE" => "Example", "NAME" => "test-name"}, "", not_closed: true)
end end
describe "when passed Hash" do it "ignores a passed block" do
it "returns a reset-'input'-element with the passed value" do output = @html.reset("Example", "test-name") { "test" }
output = @html.reset("Example") output.should equal_element("INPUT", {"TYPE" => "reset", "VALUE" => "Example", "NAME" => "test-name"}, "", not_closed: true)
output.should equal_element("INPUT", {"TYPE" => "reset", "VALUE" => "Example"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed Hash" do
output = @html.reset("Example") { "test" } it "returns a reset-'input'-element with the passed value" do
output.should equal_element("INPUT", {"TYPE" => "reset", "VALUE" => "Example"}, "", not_closed: true) output = @html.reset("Example")
output.should equal_element("INPUT", {"TYPE" => "reset", "VALUE" => "Example"}, "", not_closed: true)
end
it "ignores a passed block" do
output = @html.reset("Example") { "test" }
output.should equal_element("INPUT", {"TYPE" => "reset", "VALUE" => "Example"}, "", not_closed: true)
end
end end
end end
end end

13
spec/ruby/library/cgi/htmlextension/scrolling_list_spec.rb
View File

@ -1,8 +1,11 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require_relative 'fixtures/common'
require 'cgi'
require_relative 'shared/popup_menu'
describe "CGI::HtmlExtension#scrolling_list" do ruby_version_is ""..."3.5" do
it_behaves_like :cgi_htmlextension_popup_menu, :scrolling_list require_relative 'fixtures/common'
require 'cgi'
require_relative 'shared/popup_menu'
describe "CGI::HtmlExtension#scrolling_list" do
it_behaves_like :cgi_htmlextension_popup_menu, :scrolling_list
end
end end

83
spec/ruby/library/cgi/htmlextension/submit_spec.rb
View File

@ -1,57 +1,60 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
describe "CGI::HtmlExtension#submit" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@html = CGISpecs.cgi_new require_relative 'fixtures/common'
end
describe "when passed no arguments" do describe "CGI::HtmlExtension#submit" do
it "returns a submit-'input'-element" do before :each do
output = @html.submit @html = CGISpecs.cgi_new
output.should equal_element("INPUT", {"TYPE" => "submit"}, "", not_closed: true)
end end
it "ignores a passed block" do describe "when passed no arguments" do
output = @html.submit { "test" } it "returns a submit-'input'-element" do
output.should equal_element("INPUT", {"TYPE" => "submit"}, "", not_closed: true) output = @html.submit
end output.should equal_element("INPUT", {"TYPE" => "submit"}, "", not_closed: true)
end end
describe "when passed value" do it "ignores a passed block" do
it "returns a submit-'input'-element with the passed value" do output = @html.submit { "test" }
output = @html.submit("Example") output.should equal_element("INPUT", {"TYPE" => "submit"}, "", not_closed: true)
output.should equal_element("INPUT", {"TYPE" => "submit", "VALUE" => "Example"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed value" do
output = @html.submit("Example") { "test" } it "returns a submit-'input'-element with the passed value" do
output.should equal_element("INPUT", {"TYPE" => "submit", "VALUE" => "Example"}, "", not_closed: true) output = @html.submit("Example")
end output.should equal_element("INPUT", {"TYPE" => "submit", "VALUE" => "Example"}, "", not_closed: true)
end end
describe "when passed value, name" do it "ignores a passed block" do
it "returns a submit-'input'-element with the passed value and the passed name" do output = @html.submit("Example") { "test" }
output = @html.submit("Example", "test-name") output.should equal_element("INPUT", {"TYPE" => "submit", "VALUE" => "Example"}, "", not_closed: true)
output.should equal_element("INPUT", {"TYPE" => "submit", "VALUE" => "Example", "NAME" => "test-name"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed value, name" do
output = @html.submit("Example", "test-name") { "test" } it "returns a submit-'input'-element with the passed value and the passed name" do
output.should equal_element("INPUT", {"TYPE" => "submit", "VALUE" => "Example", "NAME" => "test-name"}, "", not_closed: true) output = @html.submit("Example", "test-name")
end output.should equal_element("INPUT", {"TYPE" => "submit", "VALUE" => "Example", "NAME" => "test-name"}, "", not_closed: true)
end end
describe "when passed Hash" do it "ignores a passed block" do
it "returns a submit-'input'-element with the passed value" do output = @html.submit("Example", "test-name") { "test" }
output = @html.submit("Example") output.should equal_element("INPUT", {"TYPE" => "submit", "VALUE" => "Example", "NAME" => "test-name"}, "", not_closed: true)
output.should equal_element("INPUT", {"TYPE" => "submit", "VALUE" => "Example"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed Hash" do
output = @html.submit("Example") { "test" } it "returns a submit-'input'-element with the passed value" do
output.should equal_element("INPUT", {"TYPE" => "submit", "VALUE" => "Example"}, "", not_closed: true) output = @html.submit("Example")
output.should equal_element("INPUT", {"TYPE" => "submit", "VALUE" => "Example"}, "", not_closed: true)
end
it "ignores a passed block" do
output = @html.submit("Example") { "test" }
output.should equal_element("INPUT", {"TYPE" => "submit", "VALUE" => "Example"}, "", not_closed: true)
end
end end
end end
end end

125
spec/ruby/library/cgi/htmlextension/text_field_spec.rb
View File

@ -1,84 +1,87 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
describe "CGI::HtmlExtension#text_field" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@html = CGISpecs.cgi_new require_relative 'fixtures/common'
end
describe "when passed no arguments" do describe "CGI::HtmlExtension#text_field" do
it "returns an text-'input'-element without a name" do before :each do
output = @html.text_field @html = CGISpecs.cgi_new
output.should equal_element("INPUT", {"NAME" => "", "TYPE" => "text", "SIZE" => "40"}, "", not_closed: true)
end end
it "ignores a passed block" do describe "when passed no arguments" do
output = @html.text_field { "test" } it "returns an text-'input'-element without a name" do
output.should equal_element("INPUT", {"NAME" => "", "TYPE" => "text", "SIZE" => "40"}, "", not_closed: true) output = @html.text_field
end output.should equal_element("INPUT", {"NAME" => "", "TYPE" => "text", "SIZE" => "40"}, "", not_closed: true)
end end
describe "when passed name" do it "ignores a passed block" do
it "returns an text-'input'-element with the passed name" do output = @html.text_field { "test" }
output = @html.text_field("test") output.should equal_element("INPUT", {"NAME" => "", "TYPE" => "text", "SIZE" => "40"}, "", not_closed: true)
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "text", "SIZE" => "40"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed name" do
output = @html.text_field("test") { "test" } it "returns an text-'input'-element with the passed name" do
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "text", "SIZE" => "40"}, "", not_closed: true) output = @html.text_field("test")
end output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "text", "SIZE" => "40"}, "", not_closed: true)
end end
describe "when passed name, value" do it "ignores a passed block" do
it "returns an text-'input'-element with the passed name and value" do output = @html.text_field("test") { "test" }
output = @html.text_field("test", "some value") output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "text", "SIZE" => "40"}, "", not_closed: true)
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "text", "VALUE" => "some value", "SIZE" => "40"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed name, value" do
output = @html.text_field("test", "some value") { "test" } it "returns an text-'input'-element with the passed name and value" do
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "text", "VALUE" => "some value", "SIZE" => "40"}, "", not_closed: true) output = @html.text_field("test", "some value")
end output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "text", "VALUE" => "some value", "SIZE" => "40"}, "", not_closed: true)
end end
describe "when passed name, value, size" do it "ignores a passed block" do
it "returns an text-'input'-element with the passed name, value and size" do output = @html.text_field("test", "some value") { "test" }
output = @html.text_field("test", "some value", 60) output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "text", "VALUE" => "some value", "SIZE" => "40"}, "", not_closed: true)
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "text", "VALUE" => "some value", "SIZE" => "60"}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed name, value, size" do
output = @html.text_field("test", "some value", 60) { "test" } it "returns an text-'input'-element with the passed name, value and size" do
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "text", "VALUE" => "some value", "SIZE" => "60"}, "", not_closed: true) output = @html.text_field("test", "some value", 60)
end output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "text", "VALUE" => "some value", "SIZE" => "60"}, "", not_closed: true)
end end
describe "when passed name, value, size, maxlength" do it "ignores a passed block" do
it "returns an text-'input'-element with the passed name, value, size and maxlength" do output = @html.text_field("test", "some value", 60) { "test" }
output = @html.text_field("test", "some value", 60, 12) output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "text", "VALUE" => "some value", "SIZE" => "60"}, "", not_closed: true)
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "text", "VALUE" => "some value", "SIZE" => "60", "MAXLENGTH" => 12}, "", not_closed: true) end
end end
it "ignores a passed block" do describe "when passed name, value, size, maxlength" do
output = @html.text_field("test", "some value", 60, 12) { "test" } it "returns an text-'input'-element with the passed name, value, size and maxlength" do
output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "text", "VALUE" => "some value", "SIZE" => "60", "MAXLENGTH" => 12}, "", not_closed: true) output = @html.text_field("test", "some value", 60, 12)
end output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "text", "VALUE" => "some value", "SIZE" => "60", "MAXLENGTH" => 12}, "", not_closed: true)
end end
describe "when passed Hash" do it "ignores a passed block" do
it "returns a checkbox-'input'-element using the passed Hash for attributes" do output = @html.text_field("test", "some value", 60, 12) { "test" }
output = @html.text_field("NAME" => "test", "VALUE" => "some value") output.should equal_element("INPUT", {"NAME" => "test", "TYPE" => "text", "VALUE" => "some value", "SIZE" => "60", "MAXLENGTH" => 12}, "", not_closed: true)
output.should equal_element("INPUT", { "NAME" => "test", "VALUE" => "some value", "TYPE" => "text" }, "", not_closed: true) end
output = @html.text_field("TYPE" => "hidden")
output.should equal_element("INPUT", {"TYPE" => "text"}, "", not_closed: true)
end end
it "ignores a passed block" do describe "when passed Hash" do
output = @html.text_field("NAME" => "test", "VALUE" => "some value") { "test" } it "returns a checkbox-'input'-element using the passed Hash for attributes" do
output.should equal_element("INPUT", { "NAME" => "test", "VALUE" => "some value", "TYPE" => "text" }, "", not_closed: true) output = @html.text_field("NAME" => "test", "VALUE" => "some value")
output.should equal_element("INPUT", { "NAME" => "test", "VALUE" => "some value", "TYPE" => "text" }, "", not_closed: true)
output = @html.text_field("TYPE" => "hidden")
output.should equal_element("INPUT", {"TYPE" => "text"}, "", not_closed: true)
end
it "ignores a passed block" do
output = @html.text_field("NAME" => "test", "VALUE" => "some value") { "test" }
output.should equal_element("INPUT", { "NAME" => "test", "VALUE" => "some value", "TYPE" => "text" }, "", not_closed: true)
end
end end
end end
end end

109
spec/ruby/library/cgi/htmlextension/textarea_spec.rb
View File

@ -1,73 +1,76 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'fixtures/common'
describe "CGI::HtmlExtension#textarea" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@html = CGISpecs.cgi_new require_relative 'fixtures/common'
end
describe "when passed no arguments" do describe "CGI::HtmlExtension#textarea" do
it "returns an 'textarea'-element without a name" do before :each do
output = @html.textarea @html = CGISpecs.cgi_new
output.should equal_element("TEXTAREA", {"NAME" => "", "COLS" => "70", "ROWS" => "10"}, "")
end end
it "includes the return value of the passed block when passed a block" do describe "when passed no arguments" do
output = @html.textarea { "Example" } it "returns an 'textarea'-element without a name" do
output.should equal_element("TEXTAREA", {"NAME" => "", "COLS" => "70", "ROWS" => "10"}, "Example") output = @html.textarea
end output.should equal_element("TEXTAREA", {"NAME" => "", "COLS" => "70", "ROWS" => "10"}, "")
end end
describe "when passed name" do it "includes the return value of the passed block when passed a block" do
it "returns an 'textarea'-element with the passed name" do output = @html.textarea { "Example" }
output = @html.textarea("test") output.should equal_element("TEXTAREA", {"NAME" => "", "COLS" => "70", "ROWS" => "10"}, "Example")
output.should equal_element("TEXTAREA", {"NAME" => "test", "COLS" => "70", "ROWS" => "10"}, "") end
end end
it "includes the return value of the passed block when passed a block" do describe "when passed name" do
output = @html.textarea("test") { "Example" } it "returns an 'textarea'-element with the passed name" do
output.should equal_element("TEXTAREA", {"NAME" => "test", "COLS" => "70", "ROWS" => "10"}, "Example") output = @html.textarea("test")
end output.should equal_element("TEXTAREA", {"NAME" => "test", "COLS" => "70", "ROWS" => "10"}, "")
end end
describe "when passed name, cols" do it "includes the return value of the passed block when passed a block" do
it "returns an 'textarea'-element with the passed name and the passed amount of columns" do output = @html.textarea("test") { "Example" }
output = @html.textarea("test", 40) output.should equal_element("TEXTAREA", {"NAME" => "test", "COLS" => "70", "ROWS" => "10"}, "Example")
output.should equal_element("TEXTAREA", {"NAME" => "test", "COLS" => "40", "ROWS" => "10"}, "") end
end end
it "includes the return value of the passed block when passed a block" do describe "when passed name, cols" do
output = @html.textarea("test", 40) { "Example" } it "returns an 'textarea'-element with the passed name and the passed amount of columns" do
output.should equal_element("TEXTAREA", {"NAME" => "test", "COLS" => "40", "ROWS" => "10"}, "Example") output = @html.textarea("test", 40)
end output.should equal_element("TEXTAREA", {"NAME" => "test", "COLS" => "40", "ROWS" => "10"}, "")
end end
describe "when passed name, cols, rows" do it "includes the return value of the passed block when passed a block" do
it "returns an 'textarea'-element with the passed name, the passed amount of columns and the passed number of rows" do output = @html.textarea("test", 40) { "Example" }
output = @html.textarea("test", 40, 5) output.should equal_element("TEXTAREA", {"NAME" => "test", "COLS" => "40", "ROWS" => "10"}, "Example")
output.should equal_element("TEXTAREA", {"NAME" => "test", "COLS" => "40", "ROWS" => "5"}, "") end
end end
it "includes the return value of the passed block when passed a block" do describe "when passed name, cols, rows" do
output = @html.textarea("test", 40, 5) { "Example" } it "returns an 'textarea'-element with the passed name, the passed amount of columns and the passed number of rows" do
output.should equal_element("TEXTAREA", {"NAME" => "test", "COLS" => "40", "ROWS" => "5"}, "Example") output = @html.textarea("test", 40, 5)
end output.should equal_element("TEXTAREA", {"NAME" => "test", "COLS" => "40", "ROWS" => "5"}, "")
end end
describe "when passed Hash" do it "includes the return value of the passed block when passed a block" do
it "uses the passed Hash as attributes" do output = @html.textarea("test", 40, 5) { "Example" }
@html.textarea("ID" => "test").should == '<TEXTAREA ID="test"></TEXTAREA>' output.should equal_element("TEXTAREA", {"NAME" => "test", "COLS" => "40", "ROWS" => "5"}, "Example")
end
attributes = {"ID" => "test-id", "NAME" => "test-name"}
output = @html.textarea(attributes)
output.should equal_element("TEXTAREA", attributes, "")
end end
it "includes the return value of the passed block when passed a block" do describe "when passed Hash" do
attributes = {"ID" => "test-id", "NAME" => "test-name"} it "uses the passed Hash as attributes" do
output = @html.textarea(attributes) { "test" } @html.textarea("ID" => "test").should == '<TEXTAREA ID="test"></TEXTAREA>'
output.should equal_element("TEXTAREA", attributes, "test")
attributes = {"ID" => "test-id", "NAME" => "test-name"}
output = @html.textarea(attributes)
output.should equal_element("TEXTAREA", attributes, "")
end
it "includes the return value of the passed block when passed a block" do
attributes = {"ID" => "test-id", "NAME" => "test-name"}
output = @html.textarea(attributes) { "test" }
output.should equal_element("TEXTAREA", attributes, "test")
end
end end
end end
end end

11
spec/ruby/library/cgi/http_header_spec.rb
View File

@ -1,8 +1,11 @@
require_relative '../../spec_helper' require_relative '../../spec_helper'
require 'cgi'
require_relative 'shared/http_header' ruby_version_is ""..."3.5" do
require 'cgi'
describe "CGI#http_header" do require_relative 'shared/http_header'
it_behaves_like :cgi_http_header, :http_header
describe "CGI#http_header" do
it_behaves_like :cgi_http_header, :http_header
end
end end

243
spec/ruby/library/cgi/initialize_spec.rb
View File

@ -1,133 +1,136 @@
require_relative '../../spec_helper' require_relative '../../spec_helper'
require 'cgi'
describe "CGI#initialize" do ruby_version_is ""..."3.5" do
it "is private" do require 'cgi'
CGI.should have_private_instance_method(:initialize)
end
end
describe "CGI#initialize when passed no arguments" do describe "CGI#initialize" do
before :each do it "is private" do
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD'] CGI.should have_private_instance_method(:initialize)
@cgi = CGI.allocate
end
after :each do
ENV['REQUEST_METHOD'] = @old_request_method
end
it "extends self with CGI::QueryExtension" do
@cgi.send(:initialize)
@cgi.should be_kind_of(CGI::QueryExtension)
end
it "does not extend self with CGI::HtmlExtension" do
@cgi.send(:initialize)
@cgi.should_not be_kind_of(CGI::HtmlExtension)
end
it "does not extend self with any of the other HTML modules" do
@cgi.send(:initialize)
@cgi.should_not be_kind_of(CGI::HtmlExtension)
@cgi.should_not be_kind_of(CGI::Html3)
@cgi.should_not be_kind_of(CGI::Html4)
@cgi.should_not be_kind_of(CGI::Html4Tr)
@cgi.should_not be_kind_of(CGI::Html4Fr)
end
it "sets #cookies based on ENV['HTTP_COOKIE']" do
begin
old_env, ENV["HTTP_COOKIE"] = ENV["HTTP_COOKIE"], "test=test yay"
@cgi.send(:initialize)
@cgi.cookies.should == { "test"=>[ "test yay" ] }
ensure
ENV["HTTP_COOKIE"] = old_env
end end
end end
it "sets #params based on ENV['QUERY_STRING'] when ENV['REQUEST_METHOD'] is GET" do describe "CGI#initialize when passed no arguments" do
begin before :each do
old_env_query, ENV["QUERY_STRING"] = ENV["QUERY_STRING"], "?test=a&test2=b" ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
old_env_method, ENV["REQUEST_METHOD"] = ENV["REQUEST_METHOD"], "GET" @cgi = CGI.allocate
end
after :each do
ENV['REQUEST_METHOD'] = @old_request_method
end
it "extends self with CGI::QueryExtension" do
@cgi.send(:initialize) @cgi.send(:initialize)
@cgi.params.should == { "test2" => ["b"], "?test" => ["a"] } @cgi.should be_kind_of(CGI::QueryExtension)
ensure end
ENV["QUERY_STRING"] = old_env_query
ENV["REQUEST_METHOD"] = old_env_method it "does not extend self with CGI::HtmlExtension" do
@cgi.send(:initialize)
@cgi.should_not be_kind_of(CGI::HtmlExtension)
end
it "does not extend self with any of the other HTML modules" do
@cgi.send(:initialize)
@cgi.should_not be_kind_of(CGI::HtmlExtension)
@cgi.should_not be_kind_of(CGI::Html3)
@cgi.should_not be_kind_of(CGI::Html4)
@cgi.should_not be_kind_of(CGI::Html4Tr)
@cgi.should_not be_kind_of(CGI::Html4Fr)
end
it "sets #cookies based on ENV['HTTP_COOKIE']" do
begin
old_env, ENV["HTTP_COOKIE"] = ENV["HTTP_COOKIE"], "test=test yay"
@cgi.send(:initialize)
@cgi.cookies.should == { "test"=>[ "test yay" ] }
ensure
ENV["HTTP_COOKIE"] = old_env
end
end
it "sets #params based on ENV['QUERY_STRING'] when ENV['REQUEST_METHOD'] is GET" do
begin
old_env_query, ENV["QUERY_STRING"] = ENV["QUERY_STRING"], "?test=a&test2=b"
old_env_method, ENV["REQUEST_METHOD"] = ENV["REQUEST_METHOD"], "GET"
@cgi.send(:initialize)
@cgi.params.should == { "test2" => ["b"], "?test" => ["a"] }
ensure
ENV["QUERY_STRING"] = old_env_query
ENV["REQUEST_METHOD"] = old_env_method
end
end
it "sets #params based on ENV['QUERY_STRING'] when ENV['REQUEST_METHOD'] is HEAD" do
begin
old_env_query, ENV["QUERY_STRING"] = ENV["QUERY_STRING"], "?test=a&test2=b"
old_env_method, ENV["REQUEST_METHOD"] = ENV["REQUEST_METHOD"], "HEAD"
@cgi.send(:initialize)
@cgi.params.should == { "test2" => ["b"], "?test" => ["a"] }
ensure
ENV["QUERY_STRING"] = old_env_query
ENV["REQUEST_METHOD"] = old_env_method
end
end end
end end
it "sets #params based on ENV['QUERY_STRING'] when ENV['REQUEST_METHOD'] is HEAD" do describe "CGI#initialize when passed type" do
begin before :each do
old_env_query, ENV["QUERY_STRING"] = ENV["QUERY_STRING"], "?test=a&test2=b" ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
old_env_method, ENV["REQUEST_METHOD"] = ENV["REQUEST_METHOD"], "HEAD" @cgi = CGI.allocate
@cgi.send(:initialize) end
@cgi.params.should == { "test2" => ["b"], "?test" => ["a"] }
ensure after :each do
ENV["QUERY_STRING"] = old_env_query ENV['REQUEST_METHOD'] = @old_request_method
ENV["REQUEST_METHOD"] = old_env_method end
it "extends self with CGI::QueryExtension" do
@cgi.send(:initialize, "test")
@cgi.should be_kind_of(CGI::QueryExtension)
end
it "extends self with CGI::QueryExtension, CGI::Html3 and CGI::HtmlExtension when the passed type is 'html3'" do
@cgi.send(:initialize, "html3")
@cgi.should be_kind_of(CGI::Html3)
@cgi.should be_kind_of(CGI::HtmlExtension)
@cgi.should be_kind_of(CGI::QueryExtension)
@cgi.should_not be_kind_of(CGI::Html4)
@cgi.should_not be_kind_of(CGI::Html4Tr)
@cgi.should_not be_kind_of(CGI::Html4Fr)
end
it "extends self with CGI::QueryExtension, CGI::Html4 and CGI::HtmlExtension when the passed type is 'html4'" do
@cgi.send(:initialize, "html4")
@cgi.should be_kind_of(CGI::Html4)
@cgi.should be_kind_of(CGI::HtmlExtension)
@cgi.should be_kind_of(CGI::QueryExtension)
@cgi.should_not be_kind_of(CGI::Html3)
@cgi.should_not be_kind_of(CGI::Html4Tr)
@cgi.should_not be_kind_of(CGI::Html4Fr)
end
it "extends self with CGI::QueryExtension, CGI::Html4Tr and CGI::HtmlExtension when the passed type is 'html4Tr'" do
@cgi.send(:initialize, "html4Tr")
@cgi.should be_kind_of(CGI::Html4Tr)
@cgi.should be_kind_of(CGI::HtmlExtension)
@cgi.should be_kind_of(CGI::QueryExtension)
@cgi.should_not be_kind_of(CGI::Html3)
@cgi.should_not be_kind_of(CGI::Html4)
@cgi.should_not be_kind_of(CGI::Html4Fr)
end
it "extends self with CGI::QueryExtension, CGI::Html4Tr, CGI::Html4Fr and CGI::HtmlExtension when the passed type is 'html4Fr'" do
@cgi.send(:initialize, "html4Fr")
@cgi.should be_kind_of(CGI::Html4Tr)
@cgi.should be_kind_of(CGI::Html4Fr)
@cgi.should be_kind_of(CGI::HtmlExtension)
@cgi.should be_kind_of(CGI::QueryExtension)
@cgi.should_not be_kind_of(CGI::Html3)
@cgi.should_not be_kind_of(CGI::Html4)
end end
end end
end end
describe "CGI#initialize when passed type" do
before :each do
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.allocate
end
after :each do
ENV['REQUEST_METHOD'] = @old_request_method
end
it "extends self with CGI::QueryExtension" do
@cgi.send(:initialize, "test")
@cgi.should be_kind_of(CGI::QueryExtension)
end
it "extends self with CGI::QueryExtension, CGI::Html3 and CGI::HtmlExtension when the passed type is 'html3'" do
@cgi.send(:initialize, "html3")
@cgi.should be_kind_of(CGI::Html3)
@cgi.should be_kind_of(CGI::HtmlExtension)
@cgi.should be_kind_of(CGI::QueryExtension)
@cgi.should_not be_kind_of(CGI::Html4)
@cgi.should_not be_kind_of(CGI::Html4Tr)
@cgi.should_not be_kind_of(CGI::Html4Fr)
end
it "extends self with CGI::QueryExtension, CGI::Html4 and CGI::HtmlExtension when the passed type is 'html4'" do
@cgi.send(:initialize, "html4")
@cgi.should be_kind_of(CGI::Html4)
@cgi.should be_kind_of(CGI::HtmlExtension)
@cgi.should be_kind_of(CGI::QueryExtension)
@cgi.should_not be_kind_of(CGI::Html3)
@cgi.should_not be_kind_of(CGI::Html4Tr)
@cgi.should_not be_kind_of(CGI::Html4Fr)
end
it "extends self with CGI::QueryExtension, CGI::Html4Tr and CGI::HtmlExtension when the passed type is 'html4Tr'" do
@cgi.send(:initialize, "html4Tr")
@cgi.should be_kind_of(CGI::Html4Tr)
@cgi.should be_kind_of(CGI::HtmlExtension)
@cgi.should be_kind_of(CGI::QueryExtension)
@cgi.should_not be_kind_of(CGI::Html3)
@cgi.should_not be_kind_of(CGI::Html4)
@cgi.should_not be_kind_of(CGI::Html4Fr)
end
it "extends self with CGI::QueryExtension, CGI::Html4Tr, CGI::Html4Fr and CGI::HtmlExtension when the passed type is 'html4Fr'" do
@cgi.send(:initialize, "html4Fr")
@cgi.should be_kind_of(CGI::Html4Tr)
@cgi.should be_kind_of(CGI::Html4Fr)
@cgi.should be_kind_of(CGI::HtmlExtension)
@cgi.should be_kind_of(CGI::QueryExtension)
@cgi.should_not be_kind_of(CGI::Html3)
@cgi.should_not be_kind_of(CGI::Html4)
end
end

89
spec/ruby/library/cgi/out_spec.rb
View File

@ -1,51 +1,54 @@
require_relative '../../spec_helper' require_relative '../../spec_helper'
require 'cgi'
describe "CGI#out" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new describe "CGI#out" do
$stdout, @old_stdout = IOStub.new, $stdout before :each do
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
$stdout, @old_stdout = IOStub.new, $stdout
end
after :each do
$stdout = @old_stdout
ENV['REQUEST_METHOD'] = @old_request_method
end
it "it writes a HTMl header based on the passed argument to $stdout" do
@cgi.out { "" }
$stdout.should == "Content-Type: text/html\r\nContent-Length: 0\r\n\r\n"
end
it "appends the block's return value to the HTML header" do
@cgi.out { "test!" }
$stdout.should == "Content-Type: text/html\r\nContent-Length: 5\r\n\r\ntest!"
end
it "automatically sets the Content-Length Header based on the block's return value" do
@cgi.out { "0123456789" }
$stdout.should == "Content-Type: text/html\r\nContent-Length: 10\r\n\r\n0123456789"
end
it "includes Cookies in the @output_cookies field" do
@cgi.instance_variable_set(:@output_cookies, ["multiple", "cookies"])
@cgi.out { "" }
$stdout.should == "Content-Type: text/html\r\nContent-Length: 0\r\nSet-Cookie: multiple\r\nSet-Cookie: cookies\r\n\r\n"
end
end end
after :each do describe "CGI#out when passed no block" do
$stdout = @old_stdout before :each do
ENV['REQUEST_METHOD'] = @old_request_method ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
end @cgi = CGI.new
end
it "it writes a HTMl header based on the passed argument to $stdout" do after :each do
@cgi.out { "" } ENV['REQUEST_METHOD'] = @old_request_method
$stdout.should == "Content-Type: text/html\r\nContent-Length: 0\r\n\r\n" end
end
it "appends the block's return value to the HTML header" do it "raises a LocalJumpError" do
@cgi.out { "test!" } -> { @cgi.out }.should raise_error(LocalJumpError)
$stdout.should == "Content-Type: text/html\r\nContent-Length: 5\r\n\r\ntest!" end
end
it "automatically sets the Content-Length Header based on the block's return value" do
@cgi.out { "0123456789" }
$stdout.should == "Content-Type: text/html\r\nContent-Length: 10\r\n\r\n0123456789"
end
it "includes Cookies in the @output_cookies field" do
@cgi.instance_variable_set(:@output_cookies, ["multiple", "cookies"])
@cgi.out { "" }
$stdout.should == "Content-Type: text/html\r\nContent-Length: 0\r\nSet-Cookie: multiple\r\nSet-Cookie: cookies\r\n\r\n"
end
end
describe "CGI#out when passed no block" do
before :each do
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do
ENV['REQUEST_METHOD'] = @old_request_method
end
it "raises a LocalJumpError" do
-> { @cgi.out }.should raise_error(LocalJumpError)
end end
end end

37
spec/ruby/library/cgi/parse_spec.rb
View File

@ -1,24 +1,27 @@
require_relative '../../spec_helper' require_relative '../../spec_helper'
require 'cgi'
describe "CGI.parse when passed String" do ruby_version_is ""..."3.5" do
it "parses a HTTP Query String into a Hash" do require 'cgi'
CGI.parse("test=test&a=b").should == { "a" => ["b"], "test" => ["test"] }
CGI.parse("test=1,2,3").should == { "test" => ["1,2,3"] }
CGI.parse("test=a&a=&b=").should == { "test" => ["a"], "a" => [""], "b" => [""] }
end
it "parses query strings with semicolons in place of ampersands" do describe "CGI.parse when passed String" do
CGI.parse("test=test;a=b").should == { "a" => ["b"], "test" => ["test"] } it "parses a HTTP Query String into a Hash" do
CGI.parse("test=a;a=;b=").should == { "test" => ["a"], "a" => [""], "b" => [""] } CGI.parse("test=test&a=b").should == { "a" => ["b"], "test" => ["test"] }
end CGI.parse("test=1,2,3").should == { "test" => ["1,2,3"] }
CGI.parse("test=a&a=&b=").should == { "test" => ["a"], "a" => [""], "b" => [""] }
end
it "allows passing multiple values for one key" do it "parses query strings with semicolons in place of ampersands" do
CGI.parse("test=1&test=2&test=3").should == { "test" => ["1", "2", "3"] } CGI.parse("test=test;a=b").should == { "a" => ["b"], "test" => ["test"] }
CGI.parse("test[]=1&test[]=2&test[]=3").should == { "test[]" => [ "1", "2", "3" ] } CGI.parse("test=a;a=;b=").should == { "test" => ["a"], "a" => [""], "b" => [""] }
end end
it "unescapes keys and values" do it "allows passing multiple values for one key" do
CGI.parse("hello%3F=hello%21").should == { "hello?" => ["hello!"] } CGI.parse("test=1&test=2&test=3").should == { "test" => ["1", "2", "3"] }
CGI.parse("test[]=1&test[]=2&test[]=3").should == { "test[]" => [ "1", "2", "3" ] }
end
it "unescapes keys and values" do
CGI.parse("hello%3F=hello%21").should == { "hello?" => ["hello!"] }
end
end end
end end

19
spec/ruby/library/cgi/pretty_spec.rb
View File

@ -1,24 +1,27 @@
require_relative '../../spec_helper' require_relative '../../spec_helper'
require 'cgi'
describe "CGI.pretty when passed html" do ruby_version_is ""..."3.5" do
it "indents the passed html String with two spaces" do require 'cgi'
CGI.pretty("<HTML><BODY></BODY></HTML>").should == <<-EOS
describe "CGI.pretty when passed html" do
it "indents the passed html String with two spaces" do
CGI.pretty("<HTML><BODY></BODY></HTML>").should == <<-EOS
<HTML> <HTML>
<BODY> <BODY>
</BODY> </BODY>
</HTML> </HTML>
EOS EOS
end
end end
end
describe "CGI.pretty when passed html, indentation_unit" do describe "CGI.pretty when passed html, indentation_unit" do
it "indents the passed html String with the passed indentation_unit" do it "indents the passed html String with the passed indentation_unit" do
CGI.pretty("<HTML><BODY></BODY></HTML>", "\t").should == <<-EOS CGI.pretty("<HTML><BODY></BODY></HTML>", "\t").should == <<-EOS
<HTML> <HTML>
\t<BODY> \t<BODY>
\t</BODY> \t</BODY>
</HTML> </HTML>
EOS EOS
end
end end
end end

39
spec/ruby/library/cgi/print_spec.rb
View File

@ -1,26 +1,29 @@
require_relative '../../spec_helper' require_relative '../../spec_helper'
require 'cgi'
describe "CGI#print" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI#print" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "passes all arguments to $stdout.print" do after :each do
$stdout.should_receive(:print).with("test") ENV['REQUEST_METHOD'] = @old_request_method
@cgi.print("test") end
$stdout.should_receive(:print).with("one", "two", "three", ["four", "five"]) it "passes all arguments to $stdout.print" do
@cgi.print("one", "two", "three", ["four", "five"]) $stdout.should_receive(:print).with("test")
end @cgi.print("test")
it "returns the result of calling $stdout.print" do $stdout.should_receive(:print).with("one", "two", "three", ["four", "five"])
$stdout.should_receive(:print).with("test").and_return(:expected) @cgi.print("one", "two", "three", ["four", "five"])
@cgi.print("test").should == :expected end
it "returns the result of calling $stdout.print" do
$stdout.should_receive(:print).with("test").and_return(:expected)
@cgi.print("test").should == :expected
end
end end
end end

33
spec/ruby/library/cgi/queryextension/accept_charset_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#accept_charset" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#accept_charset" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['HTTP_ACCEPT_CHARSET']" do after :each do
old_value, ENV['HTTP_ACCEPT_CHARSET'] = ENV['HTTP_ACCEPT_CHARSET'], "ISO-8859-1,utf-8;q=0.7,*;q=0.7" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.accept_charset.should == "ISO-8859-1,utf-8;q=0.7,*;q=0.7"
ensure it "returns ENV['HTTP_ACCEPT_CHARSET']" do
ENV['HTTP_ACCEPT_CHARSET'] = old_value old_value, ENV['HTTP_ACCEPT_CHARSET'] = ENV['HTTP_ACCEPT_CHARSET'], "ISO-8859-1,utf-8;q=0.7,*;q=0.7"
begin
@cgi.accept_charset.should == "ISO-8859-1,utf-8;q=0.7,*;q=0.7"
ensure
ENV['HTTP_ACCEPT_CHARSET'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/accept_encoding_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#accept_encoding" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#accept_encoding" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['HTTP_ACCEPT_ENCODING']" do after :each do
old_value, ENV['HTTP_ACCEPT_ENCODING'] = ENV['HTTP_ACCEPT_ENCODING'], "gzip,deflate" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.accept_encoding.should == "gzip,deflate"
ensure it "returns ENV['HTTP_ACCEPT_ENCODING']" do
ENV['HTTP_ACCEPT_ENCODING'] = old_value old_value, ENV['HTTP_ACCEPT_ENCODING'] = ENV['HTTP_ACCEPT_ENCODING'], "gzip,deflate"
begin
@cgi.accept_encoding.should == "gzip,deflate"
ensure
ENV['HTTP_ACCEPT_ENCODING'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/accept_language_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#accept_language" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#accept_language" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['HTTP_ACCEPT_LANGUAGE']" do after :each do
old_value, ENV['HTTP_ACCEPT_LANGUAGE'] = ENV['HTTP_ACCEPT_LANGUAGE'], "en-us,en;q=0.5" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.accept_language.should == "en-us,en;q=0.5"
ensure it "returns ENV['HTTP_ACCEPT_LANGUAGE']" do
ENV['HTTP_ACCEPT_LANGUAGE'] = old_value old_value, ENV['HTTP_ACCEPT_LANGUAGE'] = ENV['HTTP_ACCEPT_LANGUAGE'], "en-us,en;q=0.5"
begin
@cgi.accept_language.should == "en-us,en;q=0.5"
ensure
ENV['HTTP_ACCEPT_LANGUAGE'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/accept_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#accept" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#accept" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['HTTP_ACCEPT']" do after :each do
old_value, ENV['HTTP_ACCEPT'] = ENV['HTTP_ACCEPT'], "text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.accept.should == "text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5"
ensure it "returns ENV['HTTP_ACCEPT']" do
ENV['HTTP_ACCEPT'] = old_value old_value, ENV['HTTP_ACCEPT'] = ENV['HTTP_ACCEPT'], "text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5"
begin
@cgi.accept.should == "text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5"
ensure
ENV['HTTP_ACCEPT'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/auth_type_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#auth_type" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#auth_type" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['AUTH_TYPE']" do after :each do
old_value, ENV['AUTH_TYPE'] = ENV['AUTH_TYPE'], "Basic" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.auth_type.should == "Basic"
ensure it "returns ENV['AUTH_TYPE']" do
ENV['AUTH_TYPE'] = old_value old_value, ENV['AUTH_TYPE'] = ENV['AUTH_TYPE'], "Basic"
begin
@cgi.auth_type.should == "Basic"
ensure
ENV['AUTH_TYPE'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/cache_control_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#cache_control" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#cache_control" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['HTTP_CACHE_CONTROL']" do after :each do
old_value, ENV['HTTP_CACHE_CONTROL'] = ENV['HTTP_CACHE_CONTROL'], "no-cache" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.cache_control.should == "no-cache"
ensure it "returns ENV['HTTP_CACHE_CONTROL']" do
ENV['HTTP_CACHE_CONTROL'] = old_value old_value, ENV['HTTP_CACHE_CONTROL'] = ENV['HTTP_CACHE_CONTROL'], "no-cache"
begin
@cgi.cache_control.should == "no-cache"
ensure
ENV['HTTP_CACHE_CONTROL'] = old_value
end
end end
end end
end end

39
spec/ruby/library/cgi/queryextension/content_length_spec.rb
View File

@ -1,26 +1,29 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#content_length" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#content_length" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['CONTENT_LENGTH'] as Integer" do after :each do
old_value = ENV['CONTENT_LENGTH'] ENV['REQUEST_METHOD'] = @old_request_method
begin end
ENV['CONTENT_LENGTH'] = nil
@cgi.content_length.should be_nil
ENV['CONTENT_LENGTH'] = "100" it "returns ENV['CONTENT_LENGTH'] as Integer" do
@cgi.content_length.should eql(100) old_value = ENV['CONTENT_LENGTH']
ensure begin
ENV['CONTENT_LENGTH'] = old_value ENV['CONTENT_LENGTH'] = nil
@cgi.content_length.should be_nil
ENV['CONTENT_LENGTH'] = "100"
@cgi.content_length.should eql(100)
ensure
ENV['CONTENT_LENGTH'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/content_type_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#content_type" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#content_type" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['CONTENT_TYPE']" do after :each do
old_value, ENV['CONTENT_TYPE'] = ENV['CONTENT_TYPE'], "text/html" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.content_type.should == "text/html"
ensure it "returns ENV['CONTENT_TYPE']" do
ENV['CONTENT_TYPE'] = old_value old_value, ENV['CONTENT_TYPE'] = ENV['CONTENT_TYPE'], "text/html"
begin
@cgi.content_type.should == "text/html"
ensure
ENV['CONTENT_TYPE'] = old_value
end
end end
end end
end end

15
spec/ruby/library/cgi/queryextension/cookies_spec.rb
View File

@ -1,10 +1,13 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#cookies" do ruby_version_is ""..."3.5" do
it "needs to be reviewed for spec completeness" require 'cgi'
end
describe "CGI::QueryExtension#cookies=" do describe "CGI::QueryExtension#cookies" do
it "needs to be reviewed for spec completeness" it "needs to be reviewed for spec completeness"
end
describe "CGI::QueryExtension#cookies=" do
it "needs to be reviewed for spec completeness"
end
end end

41
spec/ruby/library/cgi/queryextension/element_reference_spec.rb
View File

@ -1,27 +1,30 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#[]" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
ENV['QUERY_STRING'], @old_query_string = "one=a&two=b&two=c", ENV['QUERY_STRING']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#[]" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
ENV['QUERY_STRING'] = @old_query_string ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
end ENV['QUERY_STRING'], @old_query_string = "one=a&two=b&two=c", ENV['QUERY_STRING']
@cgi = CGI.new
end
it "it returns the value for the parameter with the given key" do after :each do
@cgi["one"].should == "a" ENV['REQUEST_METHOD'] = @old_request_method
end ENV['QUERY_STRING'] = @old_query_string
end
it "only returns the first value for parameters with multiple values" do it "it returns the value for the parameter with the given key" do
@cgi["two"].should == "b" @cgi["one"].should == "a"
end end
it "returns a String" do it "only returns the first value for parameters with multiple values" do
@cgi["one"].should be_kind_of(String) @cgi["two"].should == "b"
end
it "returns a String" do
@cgi["one"].should be_kind_of(String)
end
end end
end end

33
spec/ruby/library/cgi/queryextension/from_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#from" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#from" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['HTTP_FROM']" do after :each do
old_value, ENV['HTTP_FROM'] = ENV['HTTP_FROM'], "googlebot(at)googlebot.com" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.from.should == "googlebot(at)googlebot.com"
ensure it "returns ENV['HTTP_FROM']" do
ENV['HTTP_FROM'] = old_value old_value, ENV['HTTP_FROM'] = ENV['HTTP_FROM'], "googlebot(at)googlebot.com"
begin
@cgi.from.should == "googlebot(at)googlebot.com"
ensure
ENV['HTTP_FROM'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/gateway_interface_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#gateway_interface" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#gateway_interface" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['GATEWAY_INTERFACE']" do after :each do
old_value, ENV['GATEWAY_INTERFACE'] = ENV['GATEWAY_INTERFACE'], "CGI/1.1" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.gateway_interface.should == "CGI/1.1"
ensure it "returns ENV['GATEWAY_INTERFACE']" do
ENV['GATEWAY_INTERFACE'] = old_value old_value, ENV['GATEWAY_INTERFACE'] = ENV['GATEWAY_INTERFACE'], "CGI/1.1"
begin
@cgi.gateway_interface.should == "CGI/1.1"
ensure
ENV['GATEWAY_INTERFACE'] = old_value
end
end end
end end
end end

11
spec/ruby/library/cgi/queryextension/has_key_spec.rb
View File

@ -1,7 +1,10 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'shared/has_key'
describe "CGI::QueryExtension#has_key?" do ruby_version_is ""..."3.5" do
it_behaves_like :cgi_query_extension_has_key_p, :has_key? require 'cgi'
require_relative 'shared/has_key'
describe "CGI::QueryExtension#has_key?" do
it_behaves_like :cgi_query_extension_has_key_p, :has_key?
end
end end

33
spec/ruby/library/cgi/queryextension/host_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#host" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#host" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['HTTP_HOST']" do after :each do
old_value, ENV['HTTP_HOST'] = ENV['HTTP_HOST'], "localhost" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.host.should == "localhost"
ensure it "returns ENV['HTTP_HOST']" do
ENV['HTTP_HOST'] = old_value old_value, ENV['HTTP_HOST'] = ENV['HTTP_HOST'], "localhost"
begin
@cgi.host.should == "localhost"
ensure
ENV['HTTP_HOST'] = old_value
end
end end
end end
end end

11
spec/ruby/library/cgi/queryextension/include_spec.rb
View File

@ -1,7 +1,10 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'shared/has_key'
describe "CGI::QueryExtension#include?" do ruby_version_is ""..."3.5" do
it_behaves_like :cgi_query_extension_has_key_p, :include? require 'cgi'
require_relative 'shared/has_key'
describe "CGI::QueryExtension#include?" do
it_behaves_like :cgi_query_extension_has_key_p, :include?
end
end end

11
spec/ruby/library/cgi/queryextension/key_spec.rb
View File

@ -1,7 +1,10 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require_relative 'shared/has_key'
describe "CGI::QueryExtension#key?" do ruby_version_is ""..."3.5" do
it_behaves_like :cgi_query_extension_has_key_p, :key? require 'cgi'
require_relative 'shared/has_key'
describe "CGI::QueryExtension#key?" do
it_behaves_like :cgi_query_extension_has_key_p, :key?
end
end end

29
spec/ruby/library/cgi/queryextension/keys_spec.rb
View File

@ -1,20 +1,23 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#keys" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
ENV['QUERY_STRING'], @old_query_string = "one=a&two=b", ENV['QUERY_STRING']
@cgi = CGI.new describe "CGI::QueryExtension#keys" do
end before :each do
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
ENV['QUERY_STRING'], @old_query_string = "one=a&two=b", ENV['QUERY_STRING']
after :each do @cgi = CGI.new
ENV['REQUEST_METHOD'] = @old_request_method end
ENV['QUERY_STRING'] = @old_query_string
end
it "returns all parameter keys as an Array" do after :each do
@cgi.keys.sort.should == ["one", "two"] ENV['REQUEST_METHOD'] = @old_request_method
ENV['QUERY_STRING'] = @old_query_string
end
it "returns all parameter keys as an Array" do
@cgi.keys.sort.should == ["one", "two"]
end
end end
end end

47
spec/ruby/library/cgi/queryextension/multipart_spec.rb
View File

@ -1,20 +1,22 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
require "stringio"
describe "CGI::QueryExtension#multipart?" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
@old_stdin = $stdin require "stringio"
@old_request_method = ENV['REQUEST_METHOD'] describe "CGI::QueryExtension#multipart?" do
@old_content_type = ENV['CONTENT_TYPE'] before :each do
@old_content_length = ENV['CONTENT_LENGTH'] @old_stdin = $stdin
ENV['REQUEST_METHOD'] = "POST" @old_request_method = ENV['REQUEST_METHOD']
ENV["CONTENT_TYPE"] = "multipart/form-data; boundary=---------------------------1137522503144128232716531729" @old_content_type = ENV['CONTENT_TYPE']
ENV["CONTENT_LENGTH"] = "222" @old_content_length = ENV['CONTENT_LENGTH']
$stdin = StringIO.new <<-EOS ENV['REQUEST_METHOD'] = "POST"
ENV["CONTENT_TYPE"] = "multipart/form-data; boundary=---------------------------1137522503144128232716531729"
ENV["CONTENT_LENGTH"] = "222"
$stdin = StringIO.new <<-EOS
-----------------------------1137522503144128232716531729\r -----------------------------1137522503144128232716531729\r
Content-Disposition: form-data; name="file"; filename=""\r Content-Disposition: form-data; name="file"; filename=""\r
Content-Type: application/octet-stream\r Content-Type: application/octet-stream\r
@ -23,18 +25,19 @@ Content-Type: application/octet-stream\r
-----------------------------1137522503144128232716531729--\r -----------------------------1137522503144128232716531729--\r
EOS EOS
@cgi = CGI.new @cgi = CGI.new
end end
after :each do after :each do
$stdin = @old_stdin $stdin = @old_stdin
ENV['REQUEST_METHOD'] = @old_request_method ENV['REQUEST_METHOD'] = @old_request_method
ENV['CONTENT_TYPE'] = @old_content_type ENV['CONTENT_TYPE'] = @old_content_type
ENV['CONTENT_LENGTH'] = @old_content_length ENV['CONTENT_LENGTH'] = @old_content_length
end end
it "returns true if the current Request is a multipart request" do it "returns true if the current Request is a multipart request" do
@cgi.multipart?.should be_true @cgi.multipart?.should be_true
end
end end
end end

33
spec/ruby/library/cgi/queryextension/negotiate_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#negotiate" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#negotiate" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['HTTP_NEGOTIATE']" do after :each do
old_value, ENV['HTTP_NEGOTIATE'] = ENV['HTTP_NEGOTIATE'], "trans" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.negotiate.should == "trans"
ensure it "returns ENV['HTTP_NEGOTIATE']" do
ENV['HTTP_NEGOTIATE'] = old_value old_value, ENV['HTTP_NEGOTIATE'] = ENV['HTTP_NEGOTIATE'], "trans"
begin
@cgi.negotiate.should == "trans"
ensure
ENV['HTTP_NEGOTIATE'] = old_value
end
end end
end end
end end

63
spec/ruby/library/cgi/queryextension/params_spec.rb
View File

@ -1,37 +1,40 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#params" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
ENV['QUERY_STRING'], @old_query_string = "one=a&two=b&two=c&three", ENV['QUERY_STRING'] describe "CGI::QueryExtension#params" do
@cgi = CGI.new before :each do
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
ENV['QUERY_STRING'], @old_query_string = "one=a&two=b&two=c&three", ENV['QUERY_STRING']
@cgi = CGI.new
end
after :each do
ENV['QUERY_STRING'] = @old_query_string
ENV['REQUEST_METHOD'] = @old_request_method
end
it "returns the parsed HTTP Query Params" do
@cgi.params.should == {"three"=>[], "two"=>["b", "c"], "one"=>["a"]}
end
end end
after :each do describe "CGI::QueryExtension#params=" do
ENV['QUERY_STRING'] = @old_query_string before :each do
ENV['REQUEST_METHOD'] = @old_request_method ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
end @cgi = CGI.new
end
it "returns the parsed HTTP Query Params" do after :each do
@cgi.params.should == {"three"=>[], "two"=>["b", "c"], "one"=>["a"]} ENV['REQUEST_METHOD'] = @old_request_method
end end
end
it "sets the HTTP Query Params to the passed argument" do
describe "CGI::QueryExtension#params=" do @cgi.params.should == {}
before :each do
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD'] @cgi.params = {"one"=>["a"], "two"=>["b", "c"]}
@cgi = CGI.new @cgi.params.should == {"one"=>["a"], "two"=>["b", "c"]}
end end
after :each do
ENV['REQUEST_METHOD'] = @old_request_method
end
it "sets the HTTP Query Params to the passed argument" do
@cgi.params.should == {}
@cgi.params = {"one"=>["a"], "two"=>["b", "c"]}
@cgi.params.should == {"one"=>["a"], "two"=>["b", "c"]}
end end
end end

33
spec/ruby/library/cgi/queryextension/path_info_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#path_info" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#path_info" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['PATH_INFO']" do after :each do
old_value, ENV['PATH_INFO'] = ENV['PATH_INFO'], "/test/path" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.path_info.should == "/test/path"
ensure it "returns ENV['PATH_INFO']" do
ENV['PATH_INFO'] = old_value old_value, ENV['PATH_INFO'] = ENV['PATH_INFO'], "/test/path"
begin
@cgi.path_info.should == "/test/path"
ensure
ENV['PATH_INFO'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/path_translated_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#path_translated" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#path_translated" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['PATH_TRANSLATED']" do after :each do
old_value, ENV['PATH_TRANSLATED'] = ENV['PATH_TRANSLATED'], "/full/path/to/dir" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.path_translated.should == "/full/path/to/dir"
ensure it "returns ENV['PATH_TRANSLATED']" do
ENV['PATH_TRANSLATED'] = old_value old_value, ENV['PATH_TRANSLATED'] = ENV['PATH_TRANSLATED'], "/full/path/to/dir"
begin
@cgi.path_translated.should == "/full/path/to/dir"
ensure
ENV['PATH_TRANSLATED'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/pragma_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#pragma" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#pragma" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['HTTP_PRAGMA']" do after :each do
old_value, ENV['HTTP_PRAGMA'] = ENV['HTTP_PRAGMA'], "no-cache" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.pragma.should == "no-cache"
ensure it "returns ENV['HTTP_PRAGMA']" do
ENV['HTTP_PRAGMA'] = old_value old_value, ENV['HTTP_PRAGMA'] = ENV['HTTP_PRAGMA'], "no-cache"
begin
@cgi.pragma.should == "no-cache"
ensure
ENV['HTTP_PRAGMA'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/query_string_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#query_string" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#query_string" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['QUERY_STRING']" do after :each do
old_value, ENV['QUERY_STRING'] = ENV['QUERY_STRING'], "one=a&two=b" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.query_string.should == "one=a&two=b"
ensure it "returns ENV['QUERY_STRING']" do
ENV['QUERY_STRING'] = old_value old_value, ENV['QUERY_STRING'] = ENV['QUERY_STRING'], "one=a&two=b"
begin
@cgi.query_string.should == "one=a&two=b"
ensure
ENV['QUERY_STRING'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/raw_cookie2_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#raw_cookie2" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#raw_cookie2" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['HTTP_COOKIE2']" do after :each do
old_value, ENV['HTTP_COOKIE2'] = ENV['HTTP_COOKIE2'], "some_cookie=data" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.raw_cookie2.should == "some_cookie=data"
ensure it "returns ENV['HTTP_COOKIE2']" do
ENV['HTTP_COOKIE2'] = old_value old_value, ENV['HTTP_COOKIE2'] = ENV['HTTP_COOKIE2'], "some_cookie=data"
begin
@cgi.raw_cookie2.should == "some_cookie=data"
ensure
ENV['HTTP_COOKIE2'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/raw_cookie_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#raw_cookie" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#raw_cookie" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['HTTP_COOKIE']" do after :each do
old_value, ENV['HTTP_COOKIE'] = ENV['HTTP_COOKIE'], "some_cookie=data" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.raw_cookie.should == "some_cookie=data"
ensure it "returns ENV['HTTP_COOKIE']" do
ENV['HTTP_COOKIE'] = old_value old_value, ENV['HTTP_COOKIE'] = ENV['HTTP_COOKIE'], "some_cookie=data"
begin
@cgi.raw_cookie.should == "some_cookie=data"
ensure
ENV['HTTP_COOKIE'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/referer_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#referer" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#referer" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['HTTP_REFERER']" do after :each do
old_value, ENV['HTTP_REFERER'] = ENV['HTTP_REFERER'], "example.com" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.referer.should == "example.com"
ensure it "returns ENV['HTTP_REFERER']" do
ENV['HTTP_REFERER'] = old_value old_value, ENV['HTTP_REFERER'] = ENV['HTTP_REFERER'], "example.com"
begin
@cgi.referer.should == "example.com"
ensure
ENV['HTTP_REFERER'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/remote_addr_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#remote_addr" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#remote_addr" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['REMOTE_ADDR']" do after :each do
old_value, ENV['REMOTE_ADDR'] = ENV['REMOTE_ADDR'], "127.0.0.1" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.remote_addr.should == "127.0.0.1"
ensure it "returns ENV['REMOTE_ADDR']" do
ENV['REMOTE_ADDR'] = old_value old_value, ENV['REMOTE_ADDR'] = ENV['REMOTE_ADDR'], "127.0.0.1"
begin
@cgi.remote_addr.should == "127.0.0.1"
ensure
ENV['REMOTE_ADDR'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/remote_host_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#remote_host" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#remote_host" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['REMOTE_HOST']" do after :each do
old_value, ENV['REMOTE_HOST'] = ENV['REMOTE_HOST'], "test.host" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.remote_host.should == "test.host"
ensure it "returns ENV['REMOTE_HOST']" do
ENV['REMOTE_HOST'] = old_value old_value, ENV['REMOTE_HOST'] = ENV['REMOTE_HOST'], "test.host"
begin
@cgi.remote_host.should == "test.host"
ensure
ENV['REMOTE_HOST'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/remote_ident_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#remote_ident" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#remote_ident" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['REMOTE_IDENT']" do after :each do
old_value, ENV['REMOTE_IDENT'] = ENV['REMOTE_IDENT'], "no-idea-what-this-is-for" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.remote_ident.should == "no-idea-what-this-is-for"
ensure it "returns ENV['REMOTE_IDENT']" do
ENV['REMOTE_IDENT'] = old_value old_value, ENV['REMOTE_IDENT'] = ENV['REMOTE_IDENT'], "no-idea-what-this-is-for"
begin
@cgi.remote_ident.should == "no-idea-what-this-is-for"
ensure
ENV['REMOTE_IDENT'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/remote_user_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#remote_user" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#remote_user" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['REMOTE_USER']" do after :each do
old_value, ENV['REMOTE_USER'] = ENV['REMOTE_USER'], "username" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.remote_user.should == "username"
ensure it "returns ENV['REMOTE_USER']" do
ENV['REMOTE_USER'] = old_value old_value, ENV['REMOTE_USER'] = ENV['REMOTE_USER'], "username"
begin
@cgi.remote_user.should == "username"
ensure
ENV['REMOTE_USER'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/request_method_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#request_method" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#request_method" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['REQUEST_METHOD']" do after :each do
old_value, ENV['REQUEST_METHOD'] = ENV['REQUEST_METHOD'], "GET" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.request_method.should == "GET"
ensure it "returns ENV['REQUEST_METHOD']" do
ENV['REQUEST_METHOD'] = old_value old_value, ENV['REQUEST_METHOD'] = ENV['REQUEST_METHOD'], "GET"
begin
@cgi.request_method.should == "GET"
ensure
ENV['REQUEST_METHOD'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/script_name_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#script_name" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#script_name" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['SCRIPT_NAME']" do after :each do
old_value, ENV['SCRIPT_NAME'] = ENV['SCRIPT_NAME'], "/path/to/script.rb" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.script_name.should == "/path/to/script.rb"
ensure it "returns ENV['SCRIPT_NAME']" do
ENV['SCRIPT_NAME'] = old_value old_value, ENV['SCRIPT_NAME'] = ENV['SCRIPT_NAME'], "/path/to/script.rb"
begin
@cgi.script_name.should == "/path/to/script.rb"
ensure
ENV['SCRIPT_NAME'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/server_name_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#server_name" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#server_name" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['SERVER_NAME']" do after :each do
old_value, ENV['SERVER_NAME'] = ENV['SERVER_NAME'], "localhost" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.server_name.should == "localhost"
ensure it "returns ENV['SERVER_NAME']" do
ENV['SERVER_NAME'] = old_value old_value, ENV['SERVER_NAME'] = ENV['SERVER_NAME'], "localhost"
begin
@cgi.server_name.should == "localhost"
ensure
ENV['SERVER_NAME'] = old_value
end
end end
end end
end end

39
spec/ruby/library/cgi/queryextension/server_port_spec.rb
View File

@ -1,26 +1,29 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#server_port" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#server_port" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['SERVER_PORT'] as Integer" do after :each do
old_value = ENV['SERVER_PORT'] ENV['REQUEST_METHOD'] = @old_request_method
begin end
ENV['SERVER_PORT'] = nil
@cgi.server_port.should be_nil
ENV['SERVER_PORT'] = "3000" it "returns ENV['SERVER_PORT'] as Integer" do
@cgi.server_port.should eql(3000) old_value = ENV['SERVER_PORT']
ensure begin
ENV['SERVER_PORT'] = old_value ENV['SERVER_PORT'] = nil
@cgi.server_port.should be_nil
ENV['SERVER_PORT'] = "3000"
@cgi.server_port.should eql(3000)
ensure
ENV['SERVER_PORT'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/server_protocol_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#server_protocol" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#server_protocol" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['SERVER_PROTOCOL']" do after :each do
old_value, ENV['SERVER_PROTOCOL'] = ENV['SERVER_PROTOCOL'], "HTTP/1.1" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.server_protocol.should == "HTTP/1.1"
ensure it "returns ENV['SERVER_PROTOCOL']" do
ENV['SERVER_PROTOCOL'] = old_value old_value, ENV['SERVER_PROTOCOL'] = ENV['SERVER_PROTOCOL'], "HTTP/1.1"
begin
@cgi.server_protocol.should == "HTTP/1.1"
ensure
ENV['SERVER_PROTOCOL'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/server_software_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#server_software" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#server_software" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['SERVER_SOFTWARE']" do after :each do
old_value, ENV['SERVER_SOFTWARE'] = ENV['SERVER_SOFTWARE'], "Server/1.0.0" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.server_software.should == "Server/1.0.0"
ensure it "returns ENV['SERVER_SOFTWARE']" do
ENV['SERVER_SOFTWARE'] = old_value old_value, ENV['SERVER_SOFTWARE'] = ENV['SERVER_SOFTWARE'], "Server/1.0.0"
begin
@cgi.server_software.should == "Server/1.0.0"
ensure
ENV['SERVER_SOFTWARE'] = old_value
end
end end
end end
end end

33
spec/ruby/library/cgi/queryextension/user_agent_spec.rb
View File

@ -1,22 +1,25 @@
require_relative '../../../spec_helper' require_relative '../../../spec_helper'
require 'cgi'
describe "CGI::QueryExtension#user_agent" do ruby_version_is ""..."3.5" do
before :each do require 'cgi'
ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
after :each do describe "CGI::QueryExtension#user_agent" do
ENV['REQUEST_METHOD'] = @old_request_method before :each do
end ENV['REQUEST_METHOD'], @old_request_method = "GET", ENV['REQUEST_METHOD']
@cgi = CGI.new
end
it "returns ENV['HTTP_USER_AGENT']" do after :each do
old_value, ENV['HTTP_USER_AGENT'] = ENV['HTTP_USER_AGENT'], "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_2; de-de) AppleWebKit/527+ (KHTML, like Gecko) Version/3.1 Safari/525.13" ENV['REQUEST_METHOD'] = @old_request_method
begin end
@cgi.user_agent.should == "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_2; de-de) AppleWebKit/527+ (KHTML, like Gecko) Version/3.1 Safari/525.13"
ensure it "returns ENV['HTTP_USER_AGENT']" do
ENV['HTTP_USER_AGENT'] = old_value old_value, ENV['HTTP_USER_AGENT'] = ENV['HTTP_USER_AGENT'], "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_2; de-de) AppleWebKit/527+ (KHTML, like Gecko) Version/3.1 Safari/525.13"
begin
@cgi.user_agent.should == "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_2; de-de) AppleWebKit/527+ (KHTML, like Gecko) Version/3.1 Safari/525.13"
ensure
ENV['HTTP_USER_AGENT'] = old_value
end
end end
end end
end end

15
spec/ruby/library/cgi/rfc1123_date_spec.rb
View File

@ -1,10 +1,13 @@
require_relative '../../spec_helper' require_relative '../../spec_helper'
require 'cgi'
describe "CGI.rfc1123_date when passed Time" do ruby_version_is ""..."3.5" do
it "returns the passed Time formatted in RFC1123 ('Sat, 01 Dec 2007 15:56:42 GMT')" do require 'cgi'
input = Time.at(1196524602)
expected = 'Sat, 01 Dec 2007 15:56:42 GMT' describe "CGI.rfc1123_date when passed Time" do
CGI.rfc1123_date(input).should == expected it "returns the passed Time formatted in RFC1123 ('Sat, 01 Dec 2007 15:56:42 GMT')" do
input = Time.at(1196524602)
expected = 'Sat, 01 Dec 2007 15:56:42 GMT'
CGI.rfc1123_date(input).should == expected
end
end end
end end

6
spec/ruby/library/cgi/unescapeElement_spec.rb
View File

@ -1,5 +1,9 @@
require_relative '../../spec_helper' require_relative '../../spec_helper'
require 'cgi' begin
require 'cgi/escape'
rescue LoadError
require 'cgi'
end
describe "CGI.unescapeElement when passed String, elements, ..." do describe "CGI.unescapeElement when passed String, elements, ..." do
it "unescapes only the tags of the passed elements in the passed String" do it "unescapes only the tags of the passed elements in the passed String" do

6
spec/ruby/library/cgi/unescapeHTML_spec.rb
View File

@ -1,5 +1,9 @@
require_relative '../../spec_helper' require_relative '../../spec_helper'
require 'cgi' begin
require 'cgi/escape'
rescue LoadError
require 'cgi'
end
describe "CGI.unescapeHTML" do describe "CGI.unescapeHTML" do
it "unescapes '&amp; &lt; &gt; &quot;' to '& < > \"'" do it "unescapes '&amp; &lt; &gt; &quot;' to '& < > \"'" do

6
spec/ruby/library/cgi/unescape_spec.rb
View File

@ -1,6 +1,10 @@
# -*- encoding: utf-8 -*- # -*- encoding: utf-8 -*-
require_relative '../../spec_helper' require_relative '../../spec_helper'
require 'cgi' begin
require 'cgi/escape'
rescue LoadError
require 'cgi'
end
describe "CGI.unescape" do describe "CGI.unescape" do
it "url-decodes the passed argument" do it "url-decodes the passed argument" do