kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity

Move spec/rubyspec to spec/ruby for consistency

Browse source 
* Other ruby implementations use the spec/ruby directory.
  [Misc #13792] [ruby-core:82287]

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@59979 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
eregon 2017-09-20 20:18:52 +00:00
parent 75bfc6440d
commit 1d15d5f080
4370 changed files with 0 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

23
spec/ruby/library/cgi/cookie/domain_spec.rb Normal file
View file

@ -0,0 +1,23 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::Cookie#domain" do
it "returns self's domain" do
cookie = CGI::Cookie.new("test-cookie")
cookie.domain.should be_nil
cookie = CGI::Cookie.new("name" => "test-cookie", "domain" => "example.com")
cookie.domain.should == "example.com"
end
end
describe "CGI::Cookie#domain=" do
it "sets self's domain" do
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

23
spec/ruby/library/cgi/cookie/expires_spec.rb Normal file
View file

@ -0,0 +1,23 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::Cookie#expires" do
it "returns self's expiration date" do
cookie = CGI::Cookie.new("test-cookie")
cookie.expires.should be_nil
cookie = CGI::Cookie.new("name" => "test-cookie", "expires" => Time.at(1196524602))
cookie.expires.should == Time.at(1196524602)
end
end
describe "CGI::Cookie#expires=" do
it "sets self's expiration date" do
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

147
spec/ruby/library/cgi/cookie/initialize_spec.rb Normal file
View file

@ -0,0 +1,147 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::Cookie#initialize when passed String" 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")
@cookie.name.should == "test-cookie"
end
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.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.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
describe "CGI::Cookie#initialize when passed Hash" do
before :each do
@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/"
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
lambda { @cookie.send(:initialize, {}) }.should raise_error(ArgumentError)
lambda { @cookie.send(:initialize, "value" => "test") }.should raise_error(ArgumentError)
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

23
spec/ruby/library/cgi/cookie/name_spec.rb Normal file
View file

@ -0,0 +1,23 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::Cookie#name" do
it "returns self's name" do
cookie = CGI::Cookie.new("test-cookie")
cookie.name.should == "test-cookie"
cookie = CGI::Cookie.new("name" => "another cookie")
cookie.name.should == "another cookie"
end
end
describe "CGI::Cookie#name=" do
it "sets self's expiration date" do
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

18
spec/ruby/library/cgi/cookie/parse_spec.rb Normal file
View file

@ -0,0 +1,18 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::Cookie.parse" do
it "parses a raw cookie string into a hash of Cookies" do
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"] }
CGI::Cookie.parse("first cookie=one&two;second cookie=three&four").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

23
spec/ruby/library/cgi/cookie/path_spec.rb Normal file
View file

@ -0,0 +1,23 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::Cookie#path" do
it "returns self's path" do
cookie = CGI::Cookie.new("test-cookie")
cookie.path.should == ""
cookie = CGI::Cookie.new("name" => "test-cookie", "path" => "/some/path/")
cookie.path.should == "/some/path/"
end
end
describe "CGI::Cookie#path=" do
it "sets self's path" do
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

70
spec/ruby/library/cgi/cookie/secure_spec.rb Normal file
View file

@ -0,0 +1,70 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
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
describe "CGI::Cookie#secure= when passed true" do
before :each do
@cookie = CGI::Cookie.new("test-cookie")
end
it "returns true" do
(@cookie.secure = true).should be_true
end
it "sets self to a secure cookie" do
@cookie.secure = true
@cookie.secure.should be_true
end
end
describe "CGI::Cookie#secure= when passed false" do
before :each do
@cookie = CGI::Cookie.new("test-cookie")
end
it "returns false" do
(@cookie.secure = false).should be_false
end
it "sets self to a non-secure cookie" do
@cookie.secure = false
@cookie.secure.should be_false
end
end
describe "CGI::Cookie#secure= when passed Object" do
before :each do
@cookie = CGI::Cookie.new("test-cookie")
end
it "does not change self's secure value" do
@cookie.secure = false
@cookie.secure = Object.new
@cookie.secure.should be_false
@cookie.secure = "Test"
@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

42
spec/ruby/library/cgi/cookie/to_s_spec.rb Normal file
View file

@ -0,0 +1,42 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::Cookie#to_s" do
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", "value")
cookie.to_s.should == "test-cookie=value; path="
cookie = CGI::Cookie.new("test-cookie", "one", "two", "three")
cookie.to_s.should == "test-cookie=one&two&three; path="
cookie = CGI::Cookie.new(
'name' => 'test-cookie',
'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("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
ruby_version_is ""..."2.5" do
it "escapes tilde" do
cookie = CGI::Cookie.new("test-cookie", "~").to_s.should == "test-cookie=%7E; path="
end
end
ruby_version_is "2.5" do
it "does not escape tilde" do
cookie = CGI::Cookie.new("test-cookie", "~").to_s.should == "test-cookie=~; path="
end
end
end

76
spec/ruby/library/cgi/cookie/value_spec.rb Normal file
View file

@ -0,0 +1,76 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::Cookie#value" do
it "returns self's value" do
cookie = CGI::Cookie.new("test-cookie")
cookie.value.should == []
cookie = CGI::Cookie.new("test-cookie", "one")
cookie.value.should == ["one"]
cookie = CGI::Cookie.new("test-cookie", "one", "two", "three")
cookie.value.should == ["one", "two", "three"]
cookie = CGI::Cookie.new("name" => "test-cookie", "value" => ["one", "two", "three"])
cookie.value.should == ["one", "two", "three"]
end
it "is in synch with self" do
fail = []
[
:pop,
:shift,
[:<<, "Hello"],
[:push, "Hello"],
[:unshift, "World"],
[:replace, ["A", "B"]],
[:[]=, 1, "Set"],
[:delete, "first"],
[:delete_at, 0],
].each do |method, *args|
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

20
spec/ruby/library/cgi/escapeElement_spec.rb Normal file
View file

@ -0,0 +1,20 @@
require File.expand_path('../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI.escapeElement when passed String, elements, ..." do
it "escapes only the tags of the passed elements in the passed String" do
res = CGI.escapeElement('<BR><A HREF="url"></A>', "A", "IMG")
res.should == "<BR>&lt;A HREF=&quot;url&quot;&gt;&lt;/A&gt;"
res = CGI.escapeElement('<BR><A HREF="url"></A>', ["A", "IMG"])
res.should == "<BR>&lt;A HREF=&quot;url&quot;&gt;&lt;/A&gt;"
end
it "is case-insensitive" do
res = CGI.escapeElement('<BR><A HREF="url"></A>', "a", "img")
res.should == '<BR>&lt;A HREF=&quot;url&quot;&gt;&lt;/A&gt;'
res = CGI.escapeElement('<br><a href="url"></a>', "A", "IMG")
res.should == '<br>&lt;a href=&quot;url&quot;&gt;&lt;/a&gt;'
end
end

13
spec/ruby/library/cgi/escapeHTML_spec.rb Normal file
View file

@ -0,0 +1,13 @@
require File.expand_path('../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI.escapeHTML" do
it "escapes special HTML characters (&\"<>') in the passed argument" do
CGI.escapeHTML(%[& < > " ']).should == '&amp; &lt; &gt; &quot; &#39;'
end
it "does not escape any other characters" do
chars = " !\#$%()*+,-./0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
CGI.escapeHTML(chars).should == chars
end
end

26
spec/ruby/library/cgi/escape_spec.rb Normal file
View file

@ -0,0 +1,26 @@
require File.expand_path('../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI.escape" do
it "url-encodes the passed argument" do
input = " !\"\#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}"
expected = "+%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"
CGI.escape(input).should == expected
input = "http://ja.wikipedia.org/wiki/\343\203\255\343\203\240\343\202\271\343\202\253\343\203\273\343\203\221\343\203\255\343\203\273\343\202\246\343\203\253\343\203\273\343\203\251\343\203\224\343\203\245\343\202\277"
expected = 'http%3A%2F%2Fja.wikipedia.org%2Fwiki%2F%E3%83%AD%E3%83%A0%E3%82%B9%E3%82%AB%E3%83%BB%E3%83%91%E3%83%AD%E3%83%BB%E3%82%A6%E3%83%AB%E3%83%BB%E3%83%A9%E3%83%94%E3%83%A5%E3%82%BF'
CGI.escape(input).should == expected
end
ruby_version_is ""..."2.5" do
it "escapes tilde" do
CGI.escape("~").should == "%7E"
end
end
ruby_version_is "2.5" do
it "does not escape tilde" do
CGI.escape("~").should == "~"
end
end
end

49
spec/ruby/library/cgi/htmlextension/a_spec.rb Normal file
View file

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

33
spec/ruby/library/cgi/htmlextension/base_spec.rb Normal file
View file

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

33
spec/ruby/library/cgi/htmlextension/blockquote_spec.rb Normal file
View file

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

22
spec/ruby/library/cgi/htmlextension/br_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
require File.expand_path('../fixtures/common', __FILE__)
describe "CGI::HtmlExtension#br" do
before :each do
@html = CGISpecs.cgi_new
end
describe "when each HTML generation" do
it "returns the doctype declaration for HTML3" do
CGISpecs.cgi_new("html3").br.should == "<BR>"
end
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

33
spec/ruby/library/cgi/htmlextension/caption_spec.rb Normal file
View file

@ -0,0 +1,33 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
require File.expand_path('../fixtures/common', __FILE__)
describe "CGI::HtmlExtension#caption" do
before :each do
@html = CGISpecs.cgi_new
end
describe "when passed a String" do
it "returns a 'caption'-element, using the passed String for the 'align'-attribute" do
output = @html.caption("left")
output.should equal_element("CAPTION", "ALIGN" => "left")
end
it "includes the passed block's return value when passed a block" do
output = @html.caption("left") { "Capital Cities" }
output.should equal_element("CAPTION", {"ALIGN" => "left"}, "Capital Cities")
end
end
describe "when passed a Hash" do
it "returns a 'caption'-element, using the passed Hash for attributes" do
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

76
spec/ruby/library/cgi/htmlextension/checkbox_group_spec.rb Normal file
View file

@ -0,0 +1,76 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
require File.expand_path('../fixtures/common', __FILE__)
describe "CGI::HtmlExtension#checkbox_group" do
before :each do
@html = CGISpecs.cgi_new
end
describe "when passed name, values ..." do
it "returns a sequence of 'checkbox'-elements with the passed name and the passed values" 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 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
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

77
spec/ruby/library/cgi/htmlextension/checkbox_spec.rb Normal file
View file

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

27
spec/ruby/library/cgi/htmlextension/doctype_spec.rb Normal file
View file

@ -0,0 +1,27 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
require File.expand_path('../fixtures/common', __FILE__)
describe "CGI::HtmlExtension#doctype" do
describe "when each HTML generation" do
it "returns the doctype declaration for HTML3" do
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
expect = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">'
CGISpecs.cgi_new("html4").doctype.should == expect
end
it "returns the doctype declaration for the Frameset version of HTML4" do
expect = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">'
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

72
spec/ruby/library/cgi/htmlextension/file_field_spec.rb Normal file
View file

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

15
spec/ruby/library/cgi/htmlextension/fixtures/common.rb Normal file
View file

@ -0,0 +1,15 @@
module CGISpecs
def self.cgi_new(html = "html4")
old_request_method = ENV['REQUEST_METHOD']
ENV['REQUEST_METHOD'] = "GET"
begin
CGI.new(tag_maker: html)
ensure
ENV['REQUEST_METHOD'] = old_request_method
end
end
def self.split(string)
string.split("<").reject { |x| x.empty? }.map { |x| "<#{x}" }
end
end

58
spec/ruby/library/cgi/htmlextension/form_spec.rb Normal file
View file

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

14
spec/ruby/library/cgi/htmlextension/frame_spec.rb Normal file
View file

@ -0,0 +1,14 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require File.expand_path('../fixtures/common', __FILE__)
require 'cgi'
describe "CGI::HtmlExtension#frame" do
before :each do
@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

14
spec/ruby/library/cgi/htmlextension/frameset_spec.rb Normal file
View file

@ -0,0 +1,14 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require File.expand_path('../fixtures/common', __FILE__)
require 'cgi'
describe "CGI::HtmlExtension#frameset" do
before :each do
@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

59
spec/ruby/library/cgi/htmlextension/hidden_spec.rb Normal file
View file

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

66
spec/ruby/library/cgi/htmlextension/html_spec.rb Normal file
View file

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

69
spec/ruby/library/cgi/htmlextension/image_button_spec.rb Normal file
View file

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

83
spec/ruby/library/cgi/htmlextension/img_spec.rb Normal file
View file

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

64
spec/ruby/library/cgi/htmlextension/multipart_form_spec.rb Normal file
View file

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

84
spec/ruby/library/cgi/htmlextension/password_field_spec.rb Normal file
View file

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

8
spec/ruby/library/cgi/htmlextension/popup_menu_spec.rb Normal file
View file

@ -0,0 +1,8 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
require File.expand_path('../fixtures/common', __FILE__)
require File.expand_path('../shared/popup_menu', __FILE__)
describe "CGI::HtmlExtension#popup_menu" do
it_behaves_like :cgi_htmlextension_popup_menu, :popup_menu
end

77
spec/ruby/library/cgi/htmlextension/radio_button_spec.rb Normal file
View file

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

77
spec/ruby/library/cgi/htmlextension/radio_group_spec.rb Normal file
View file

@ -0,0 +1,77 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
require File.expand_path('../fixtures/common', __FILE__)
describe "CGI::HtmlExtension#radio_group" do
before :each do
@html = CGISpecs.cgi_new
end
describe "when passed name, values ..." do
it "returns a sequence of 'radio'-elements with the passed name and the passed values" 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 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
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

57
spec/ruby/library/cgi/htmlextension/reset_spec.rb Normal file
View file

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

8
spec/ruby/library/cgi/htmlextension/scrolling_list_spec.rb Normal file
View file

@ -0,0 +1,8 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require File.expand_path('../fixtures/common', __FILE__)
require 'cgi'
require File.expand_path('../shared/popup_menu', __FILE__)
describe "CGI::HtmlExtension#scrolling_list" do
it_behaves_like :cgi_htmlextension_popup_menu, :scrolling_list
end

94
spec/ruby/library/cgi/htmlextension/shared/popup_menu.rb Normal file
View file

@ -0,0 +1,94 @@
describe :cgi_htmlextension_popup_menu, shared: true do
before :each do
@html = CGISpecs.cgi_new
end
describe "when passed no arguments" do
it "returns an empty 'select'-element without a name" do
output = @html.send(@method)
output.should equal_element("SELECT", {"NAME" => ""}, "")
end
it "ignores a passed block" do
output = @html.send(@method) { "test" }
output.should equal_element("SELECT", {"NAME" => ""}, "")
end
end
describe "when passed name, values ..." do
it "returns a 'select'-element with the passed name containing 'option'-elements based on the passed values" do
content = @html.option("VALUE" => "foo") { "foo" }
content << @html.option("VALUE" => "bar") { "bar" }
content << @html.option("VALUE" => "baz") { "baz" }
output = @html.send(@method, "test", "foo", "bar", "baz")
output.should equal_element("SELECT", {"NAME" => "test"}, content)
end
it "allows passing values inside of arrays" do
content = @html.option("VALUE" => "foo") { "foo" }
content << @html.option("VALUE" => "bar") { "bar" }
content << @html.option("VALUE" => "baz") { "baz" }
output = @html.send(@method, "test", ["foo"], ["bar"], ["baz"])
output.should equal_element("SELECT", {"NAME" => "test"}, content)
end
it "allows passing a value as an Array containing the value and the select state or a label" do
content = @html.option("VALUE" => "foo") { "foo" }
content << @html.option("VALUE" => "bar", "SELECTED" => true) { "bar" }
content << @html.option("VALUE" => "baz") { "baz" }
output = @html.send(@method, "test", ["foo"], ["bar", true], "baz")
output.should equal_element("SELECT", {"NAME" => "test"}, content)
end
it "allows passing a value as an Array containing the value, a label and the select state" do
content = @html.option("VALUE" => "1") { "Foo" }
content << @html.option("VALUE" => "2", "SELECTED" => true) { "Bar" }
content << @html.option("VALUE" => "Baz") { "Baz" }
output = @html.send(@method, "test", ["1", "Foo"], ["2", "Bar", true], "Baz")
output.should equal_element("SELECT", {"NAME" => "test"}, content)
end
it "ignores a passed block" do
content = @html.option("VALUE" => "foo") { "foo" }
content << @html.option("VALUE" => "bar") { "bar" }
content << @html.option("VALUE" => "baz") { "baz" }
output = @html.send(@method, "test", "foo", "bar", "baz") { "woot" }
output.should equal_element("SELECT", {"NAME" => "test"}, content)
end
end
describe "when passed a Hash" do
it "uses the passed Hash to generate the 'select'-element and the 'option'-elements" do
attributes = {
"NAME" => "test", "SIZE" => 2, "MULTIPLE" => true,
"VALUES" => [["1", "Foo"], ["2", "Bar", true], "Baz"]
}
content = @html.option("VALUE" => "1") { "Foo" }
content << @html.option("VALUE" => "2", "SELECTED" => true) { "Bar" }
content << @html.option("VALUE" => "Baz") { "Baz" }
output = @html.send(@method, attributes)
output.should equal_element("SELECT", {"NAME" => "test", "SIZE" => 2, "MULTIPLE" => true}, content)
end
it "ignores a passed block" do
attributes = {
"NAME" => "test", "SIZE" => 2, "MULTIPLE" => true,
"VALUES" => [["1", "Foo"], ["2", "Bar", true], "Baz"]
}
content = @html.option("VALUE" => "1") { "Foo" }
content << @html.option("VALUE" => "2", "SELECTED" => true) { "Bar" }
content << @html.option("VALUE" => "Baz") { "Baz" }
output = @html.send(@method, attributes) { "testing" }
output.should equal_element("SELECT", {"NAME" => "test", "SIZE" => 2, "MULTIPLE" => true}, content)
end
end
end

57
spec/ruby/library/cgi/htmlextension/submit_spec.rb Normal file
View file

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

84
spec/ruby/library/cgi/htmlextension/text_field_spec.rb Normal file
View file

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

73
spec/ruby/library/cgi/htmlextension/textarea_spec.rb Normal file
View file

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

8
spec/ruby/library/cgi/http_header_spec.rb Normal file
View file

@ -0,0 +1,8 @@
require File.expand_path('../../../spec_helper', __FILE__)
require 'cgi'
require File.expand_path('../shared/http_header', __FILE__)
describe "CGI#http_header" do
it_behaves_like(:cgi_http_header, :http_header)
end

133
spec/ruby/library/cgi/initialize_spec.rb Normal file
View file

@ -0,0 +1,133 @@
require File.expand_path('../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI#initialize" do
it "is private" do
CGI.should have_private_instance_method(:initialize)
end
end
describe "CGI#initialize when passed no arguments" 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)
@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::Html3)
@cgi.should_not be_kind_of(CGI::HtmlExtension)
@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
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

51
spec/ruby/library/cgi/out_spec.rb Normal file
View file

@ -0,0 +1,51 @@
require File.expand_path('../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI#out" do
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
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
lambda { @cgi.out }.should raise_error(LocalJumpError)
end
end

24
spec/ruby/library/cgi/parse_spec.rb Normal file
View file

@ -0,0 +1,24 @@
require File.expand_path('../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI.parse when passed String" do
it "parses a HTTP Query String into a Hash" do
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
CGI.parse("test=test;a=b").should == { "a" => ["b"], "test" => ["test"] }
CGI.parse("test=a;a=;b=").should == { "test" => ["a"], "a" => [""], "b" => [""] }
end
it "allows passing multiple values for one key" do
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

24
spec/ruby/library/cgi/pretty_spec.rb Normal file
View file

@ -0,0 +1,24 @@
require File.expand_path('../../../spec_helper', __FILE__)
require 'cgi'
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>
<BODY>
</BODY>
</HTML>
EOS
end
end
describe "CGI.pretty when passed html, indentation_unit" do
it "indents the passed html String with the passed indentation_unit" do
CGI.pretty("<HTML><BODY></BODY></HTML>", "\t").should == <<-EOS
<HTML>
\t<BODY>
\t</BODY>
</HTML>
EOS
end
end

26
spec/ruby/library/cgi/print_spec.rb Normal file
View file

@ -0,0 +1,26 @@
require File.expand_path('../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI#print" 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 "passes all arguments to $stdout.print" do
$stdout.should_receive(:print).with("test")
@cgi.print("test")
$stdout.should_receive(:print).with("one", "two", "three", ["four", "five"])
@cgi.print("one", "two", "three", ["four", "five"])
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

22
spec/ruby/library/cgi/queryextension/accept_charset_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#accept_charset" 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 "returns ENV['HTTP_ACCEPT_CHARSET']" do
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

22
spec/ruby/library/cgi/queryextension/accept_encoding_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#accept_encoding" 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 "returns ENV['HTTP_ACCEPT_ENCODING']" do
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

22
spec/ruby/library/cgi/queryextension/accept_language_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#accept_language" 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 "returns ENV['HTTP_ACCEPT_LANGUAGE']" do
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

22
spec/ruby/library/cgi/queryextension/accept_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#accept" 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 "returns ENV['HTTP_ACCEPT']" 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"
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

22
spec/ruby/library/cgi/queryextension/auth_type_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#auth_type" 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 "returns ENV['AUTH_TYPE']" do
old_value, ENV['AUTH_TYPE'] = ENV['AUTH_TYPE'], "Basic"
begin
@cgi.auth_type.should == "Basic"
ensure
ENV['AUTH_TYPE'] = old_value
end
end
end

22
spec/ruby/library/cgi/queryextension/cache_control_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#cache_control" 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 "returns ENV['HTTP_CACHE_CONTROL']" do
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

26
spec/ruby/library/cgi/queryextension/content_length_spec.rb Normal file
View file

@ -0,0 +1,26 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#content_length" 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 "returns ENV['CONTENT_LENGTH'] as Integer" do
old_value = ENV['CONTENT_LENGTH']
begin
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

22
spec/ruby/library/cgi/queryextension/content_type_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#content_type" 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 "returns ENV['CONTENT_TYPE']" do
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

10
spec/ruby/library/cgi/queryextension/cookies_spec.rb Normal file
View file

@ -0,0 +1,10 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#cookies" do
it "needs to be reviewed for spec completeness"
end
describe "CGI::QueryExtension#cookies=" do
it "needs to be reviewed for spec completeness"
end

27
spec/ruby/library/cgi/queryextension/element_reference_spec.rb Normal file
View file

@ -0,0 +1,27 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#[]" do
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", ENV['QUERY_STRING']
@cgi = CGI.new
end
after :each do
ENV['REQUEST_METHOD'] = @old_request_method
ENV['QUERY_STRING'] = @old_query_string
end
it "it returns the value for the parameter with the given key" do
@cgi["one"].should == "a"
end
it "only returns the first value for parameters with multiple values" do
@cgi["two"].should == "b"
end
it "returns a String" do
@cgi["one"].should be_kind_of(String)
end
end

22
spec/ruby/library/cgi/queryextension/from_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#from" 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 "returns ENV['HTTP_FROM']" do
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

22
spec/ruby/library/cgi/queryextension/gateway_interface_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#gateway_interface" 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 "returns ENV['GATEWAY_INTERFACE']" do
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

7
spec/ruby/library/cgi/queryextension/has_key_spec.rb Normal file
View file

@ -0,0 +1,7 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
require File.expand_path('../shared/has_key', __FILE__)
describe "CGI::QueryExtension#has_key?" do
it_behaves_like :cgi_query_extension_has_key_p, :has_key?
end

22
spec/ruby/library/cgi/queryextension/host_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#host" 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 "returns ENV['HTTP_HOST']" do
old_value, ENV['HTTP_HOST'] = ENV['HTTP_HOST'], "localhost"
begin
@cgi.host.should == "localhost"
ensure
ENV['HTTP_HOST'] = old_value
end
end
end

7
spec/ruby/library/cgi/queryextension/include_spec.rb Normal file
View file

@ -0,0 +1,7 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
require File.expand_path('../shared/has_key', __FILE__)
describe "CGI::QueryExtension#include?" do
it_behaves_like :cgi_query_extension_has_key_p, :include?
end

7
spec/ruby/library/cgi/queryextension/key_spec.rb Normal file
View file

@ -0,0 +1,7 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
require File.expand_path('../shared/has_key', __FILE__)
describe "CGI::QueryExtension#key?" do
it_behaves_like :cgi_query_extension_has_key_p, :key?
end

20
spec/ruby/library/cgi/queryextension/keys_spec.rb Normal file
View file

@ -0,0 +1,20 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#keys" do
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']
@cgi = CGI.new
end
after :each do
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

40
spec/ruby/library/cgi/queryextension/multipart_spec.rb Normal file
View file

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

22
spec/ruby/library/cgi/queryextension/negotiate_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#negotiate" 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 "returns ENV['HTTP_NEGOTIATE']" do
old_value, ENV['HTTP_NEGOTIATE'] = ENV['HTTP_NEGOTIATE'], "trans"
begin
@cgi.negotiate.should == "trans"
ensure
ENV['HTTP_NEGOTIATE'] = old_value
end
end
end

37
spec/ruby/library/cgi/queryextension/params_spec.rb Normal file
View file

@ -0,0 +1,37 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#params" do
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
describe "CGI::QueryExtension#params=" 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 "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

22
spec/ruby/library/cgi/queryextension/path_info_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#path_info" 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 "returns ENV['PATH_INFO']" do
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

22
spec/ruby/library/cgi/queryextension/path_translated_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#path_translated" 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 "returns ENV['PATH_TRANSLATED']" do
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

22
spec/ruby/library/cgi/queryextension/pragma_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#pragma" 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 "returns ENV['HTTP_PRAGMA']" do
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

22
spec/ruby/library/cgi/queryextension/query_string_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#query_string" 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 "returns ENV['QUERY_STRING']" do
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

22
spec/ruby/library/cgi/queryextension/raw_cookie2_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#raw_cookie2" 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 "returns ENV['HTTP_COOKIE2']" do
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

22
spec/ruby/library/cgi/queryextension/raw_cookie_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#raw_cookie" 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 "returns ENV['HTTP_COOKIE']" do
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

22
spec/ruby/library/cgi/queryextension/referer_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#referer" 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 "returns ENV['HTTP_REFERER']" do
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

22
spec/ruby/library/cgi/queryextension/remote_addr_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#remote_addr" 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 "returns ENV['REMOTE_ADDR']" do
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

22
spec/ruby/library/cgi/queryextension/remote_host_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#remote_host" 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 "returns ENV['REMOTE_HOST']" do
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

22
spec/ruby/library/cgi/queryextension/remote_ident_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#remote_ident" 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 "returns ENV['REMOTE_IDENT']" do
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

22
spec/ruby/library/cgi/queryextension/remote_user_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#remote_user" 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 "returns ENV['REMOTE_USER']" do
old_value, ENV['REMOTE_USER'] = ENV['REMOTE_USER'], "username"
begin
@cgi.remote_user.should == "username"
ensure
ENV['REMOTE_USER'] = old_value
end
end
end

22
spec/ruby/library/cgi/queryextension/request_method_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#request_method" 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 "returns ENV['REQUEST_METHOD']" do
old_value, ENV['REQUEST_METHOD'] = ENV['REQUEST_METHOD'], "GET"
begin
@cgi.request_method.should == "GET"
ensure
ENV['REQUEST_METHOD'] = old_value
end
end
end

22
spec/ruby/library/cgi/queryextension/script_name_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#script_name" 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 "returns ENV['SCRIPT_NAME']" do
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

22
spec/ruby/library/cgi/queryextension/server_name_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#server_name" 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 "returns ENV['SERVER_NAME']" do
old_value, ENV['SERVER_NAME'] = ENV['SERVER_NAME'], "localhost"
begin
@cgi.server_name.should == "localhost"
ensure
ENV['SERVER_NAME'] = old_value
end
end
end

26
spec/ruby/library/cgi/queryextension/server_port_spec.rb Normal file
View file

@ -0,0 +1,26 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#server_port" 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 "returns ENV['SERVER_PORT'] as Integer" do
old_value = ENV['SERVER_PORT']
begin
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

22
spec/ruby/library/cgi/queryextension/server_protocol_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#server_protocol" 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 "returns ENV['SERVER_PROTOCOL']" do
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

22
spec/ruby/library/cgi/queryextension/server_software_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#server_software" 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 "returns ENV['SERVER_SOFTWARE']" do
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

19
spec/ruby/library/cgi/queryextension/shared/has_key.rb Normal file
View file

@ -0,0 +1,19 @@
describe :cgi_query_extension_has_key_p, shared: true do
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']
@cgi = CGI.new
end
after :each do
ENV['REQUEST_METHOD'] = @old_request_method
ENV['QUERY_STRING'] = @old_query_string
end
it "returns true when the passed key exists in the HTTP Query" do
@cgi.send(@method, "one").should be_true
@cgi.send(@method, "two").should be_true
@cgi.send(@method, "three").should be_false
end
end

22
spec/ruby/library/cgi/queryextension/user_agent_spec.rb Normal file
View file

@ -0,0 +1,22 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI::QueryExtension#user_agent" 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 "returns ENV['HTTP_USER_AGENT']" 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"
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

10
spec/ruby/library/cgi/rfc1123_date_spec.rb Normal file
View file

@ -0,0 +1,10 @@
require File.expand_path('../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI.rfc1123_date when passsed Time" do
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

112
spec/ruby/library/cgi/shared/http_header.rb Normal file
View file

@ -0,0 +1,112 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'cgi'
describe :cgi_http_header, shared: true do
describe "CGI#http_header when passed no arguments" 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 "returns a HTTP header specifiying the Content-Type as text/html" do
@cgi.send(@method).should == "Content-Type: text/html\r\n\r\n"
end
it "includes Cookies in the @output_cookies field" do
@cgi.instance_variable_set(:@output_cookies, ["multiple", "cookies"])
@cgi.send(@method).should == "Content-Type: text/html\r\nSet-Cookie: multiple\r\nSet-Cookie: cookies\r\n\r\n"
end
end
describe "CGI#http_header when passed String" 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 "returns a HTTP header specifiying the Content-Type as the passed String's content" do
@cgi.send(@method, "text/plain").should == "Content-Type: text/plain\r\n\r\n"
end
it "includes Cookies in the @output_cookies field" do
@cgi.instance_variable_set(:@output_cookies, ["multiple", "cookies"])
@cgi.send(@method, "text/plain").should == "Content-Type: text/plain\r\nSet-Cookie: multiple\r\nSet-Cookie: cookies\r\n\r\n"
end
end
describe "CGI#http_header when passed Hash" 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 "returns a HTTP header based on the Hash's key/value pairs" do
header = @cgi.send(@method, "type" => "text/plain")
header.should == "Content-Type: text/plain\r\n\r\n"
header = @cgi.send(@method, "type" => "text/plain", "charset" => "UTF-8")
header.should == "Content-Type: text/plain; charset=UTF-8\r\n\r\n"
header = @cgi.send(@method, "nph" => true)
header.should include("HTTP/1.0 200 OK\r\n")
header.should include("Date: ")
header.should include("Server: ")
header.should include("Connection: close\r\n")
header.should include("Content-Type: text/html\r\n")
header = @cgi.send(@method, "status" => "OK")
header.should == "Status: 200 OK\r\nContent-Type: text/html\r\n\r\n"
header = @cgi.send(@method, "status" => "PARTIAL_CONTENT")
header.should == "Status: 206 Partial Content\r\nContent-Type: text/html\r\n\r\n"
header = @cgi.send(@method, "status" => "MULTIPLE_CHOICES")
header.should == "Status: 300 Multiple Choices\r\nContent-Type: text/html\r\n\r\n"
header = @cgi.send(@method, "server" => "Server Software used")
header.should == "Server: Server Software used\r\nContent-Type: text/html\r\n\r\n"
header = @cgi.send(@method, "connection" => "connection type")
header.should == "Connection: connection type\r\nContent-Type: text/html\r\n\r\n"
header = @cgi.send(@method, "length" => 103)
header.should == "Content-Type: text/html\r\nContent-Length: 103\r\n\r\n"
header = @cgi.send(@method, "language" => "ja")
header.should == "Content-Type: text/html\r\nContent-Language: ja\r\n\r\n"
header = @cgi.send(@method, "expires" => Time.at(0))
header.should == "Content-Type: text/html\r\nExpires: Thu, 01 Jan 1970 00:00:00 GMT\r\n\r\n"
header = @cgi.send(@method, "cookie" => "my cookie's content")
header.should == "Content-Type: text/html\r\nSet-Cookie: my cookie's content\r\n\r\n"
header = @cgi.send(@method, "cookie" => ["multiple", "cookies"])
header.should == "Content-Type: text/html\r\nSet-Cookie: multiple\r\nSet-Cookie: cookies\r\n\r\n"
end
it "includes Cookies in the @output_cookies field" do
@cgi.instance_variable_set(:@output_cookies, ["multiple", "cookies"])
@cgi.send(@method, {}).should == "Content-Type: text/html\r\nSet-Cookie: multiple\r\nSet-Cookie: cookies\r\n\r\n"
end
it "returns a HTTP header specifiying the Content-Type as text/html when passed an empty Hash" do
@cgi.send(@method, {}).should == "Content-Type: text/html\r\n\r\n"
end
end
end

20
spec/ruby/library/cgi/unescapeElement_spec.rb Normal file
View file

@ -0,0 +1,20 @@
require File.expand_path('../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI.unescapeElement when passed String, elements, ..." do
it "unescapes only the tags of the passed elements in the passed String" do
res = CGI.unescapeElement("&lt;BR&gt;&lt;A HREF=&quot;url&quot;&gt;&lt;/A&gt;", "A", "IMG")
res.should == '&lt;BR&gt;<A HREF="url"></A>'
res = CGI.unescapeElement('&lt;BR&gt;&lt;A HREF=&quot;url&quot;&gt;&lt;/A&gt;', ["A", "IMG"])
res.should == '&lt;BR&gt;<A HREF="url"></A>'
end
it "is case-insensitive" do
res = CGI.unescapeElement("&lt;BR&gt;&lt;A HREF=&quot;url&quot;&gt;&lt;/A&gt;", "a", "img")
res.should == '&lt;BR&gt;<A HREF="url"></A>'
res = CGI.unescapeElement("&lt;br&gt;&lt;a href=&quot;url&quot;&gt;&lt;/a&gt;", "A", "IMG")
res.should == '&lt;br&gt;<a href="url"></a>'
end
end

39
spec/ruby/library/cgi/unescapeHTML_spec.rb Normal file
View file

@ -0,0 +1,39 @@
require File.expand_path('../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI.unescapeHTML" do
it "unescapes '&amp; &lt; &gt; &quot;' to '& < > \"'" do
input = '&amp; &lt; &gt; &quot;'
expected = '& < > "'
CGI.unescapeHTML(input).should == expected
end
it "doesn't unescape other html entities such as '&copy;' or '&heart'" do
input = '&copy;&heart;'
expected = input
CGI.unescapeHTML(input).should == expected
end
it "unescapes '&#99' format entities" do
input = '&#34;&#38;&#39;&#60;&#62;'
expected = '"&\'<>'
CGI.unescapeHTML(input).should == expected
end
it "unescapes '&#x9999' format entities" do
input = '&#x0022;&#x0026;&#x0027;&#x003c;&#x003E;'
expected = '"&\'<>'
CGI.unescapeHTML(input).should == expected
end
it "leaves invalid formatted strings" do
input = '&&lt;&amp&gt;&quot&abcdefghijklmn'
expected = '&<&amp>&quot&abcdefghijklmn'
CGI.unescapeHTML(input).should == expected
end
it "leaves partial invalid &# at end of string" do
input = "fooooooo&#"
CGI.unescapeHTML(input).should == input
end
end

15
spec/ruby/library/cgi/unescape_spec.rb Normal file
View file

@ -0,0 +1,15 @@
# -*- encoding: utf-8 -*-
require File.expand_path('../../../spec_helper', __FILE__)
require 'cgi'
describe "CGI.unescape" do
it "url-decodes the passed argument" do
input = "+%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 = " !\"\#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
CGI.unescape(input).should == expected
input = 'http%3A%2F%2Fja.wikipedia.org%2Fwiki%2F%E3%83%AD%E3%83%A0%E3%82%B9%E3%82%AB%E3%83%BB%E3%83%91%E3%83%AD%E3%83%BB%E3%82%A6%E3%83%AB%E3%83%BB%E3%83%A9%E3%83%94%E3%83%A5%E3%82%BF'
expected = "http://ja.wikipedia.org/wiki/\343\203\255\343\203\240\343\202\271\343\202\253\343\203\273\343\203\221\343\203\255\343\203\273\343\202\246\343\203\253\343\203\273\343\203\251\343\203\224\343\203\245\343\202\277"
CGI.unescape(input).should == expected
end
end