old

hello") doc.title = "new" assert_equal("new", doc.title) assert_instance_of(Nokogiri::XML::DTD, doc.children.first) assert_equal(-1, doc.at("title") <=> doc.at("p")) doc = Nokogiri::HTML("") doc.title = "new" assert_equal("new", doc.title) assert_equal("new", doc.at("/html/head/title/text()").to_s) end def test_meta_encoding_without_head encoding = "EUC-JP" html = Nokogiri::HTML("foo", nil, encoding) assert_nil(html.meta_encoding) html.meta_encoding = encoding assert_equal(encoding, html.meta_encoding) meta = html.at("/html/head/meta[@http-equiv and boolean(@content)]") assert(meta, "meta is in head") assert(meta.at("./parent::head/following-sibling::body"), "meta is before body") end def test_html5_meta_encoding_without_head encoding = "EUC-JP" html = Nokogiri::HTML("foo", nil, encoding) assert_nil(html.meta_encoding) html.meta_encoding = encoding assert_equal(encoding, html.meta_encoding) meta = html.at("/html/head/meta[@charset]") assert(meta, "meta is in head") assert(meta.at("./parent::head/following-sibling::body"), "meta is before body") end def test_meta_encoding_with_empty_content_type html = Nokogiri::HTML(<<~EOHTML) foo EOHTML assert_nil(html.meta_encoding) html = Nokogiri::HTML(<<~EOHTML) foo EOHTML assert_nil(html.meta_encoding) end def test_root_node_parent_is_document parent = html.root.parent assert_equal(html, parent) assert_instance_of(Nokogiri::HTML::Document, parent) end def test_parse_handles_nil_gracefully @doc = Nokogiri::HTML::Document.parse(nil) assert_instance_of(Nokogiri::HTML::Document, @doc) end def test_parse_empty_document doc = Nokogiri::HTML("\n") assert_equal(0, doc.css("a").length) assert_equal(0, doc.xpath("//a").length) assert_equal(0, doc.search("//a").length) end def test_HTML_function html = Nokogiri::HTML(File.read(HTML_FILE)) assert_predicate(html, :html?) end def test_parse_works_with_an_object_that_responds_to_read klass = Class.new do def initialize super @contents = StringIO.new("

p tag

a tag

EOHTML set = html.css("p, a") assert_equal(2, set.length) assert_equal(["a tag", "p tag"].sort, set.map(&:content).sort) end def test_inner_text html = Nokogiri::HTML(<<~EOHTML)

Hello world!

EOHTML node = html.xpath("//div").first assert_equal("Hello world!", node.inner_text.strip) end def test_doc_type html = Nokogiri::HTML(<<~EOHTML)

Rainbow Dash

EOHTML assert_equal("html", html.internal_subset.name) assert_equal("-//W3C//DTD XHTML 1.1//EN", html.internal_subset.external_id) assert_equal("http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd", html.internal_subset.system_id) assert_equal( "", html.to_s[0, 97] ) end def test_content_size html = Nokogiri::HTML("

") assert_equal(1, html.content.size) assert_equal(1, html.content.split("").size) assert_equal("\n", html.content) end def test_find_by_xpath found = html.xpath("//div/a") assert_equal(3, found.length) end def test_find_by_css found = html.css("div > a") assert_equal(3, found.length) end def test_find_by_css_with_square_brackets found = html.css("div[@id='header'] > h1") refute_nil(found) assert_equal(1, found.length) # this blows up on commit 6fa0f6d329d9dbf1cc21c0ac72f7e627bb4c05fc found = html.css("div[@id='header'] h1") refute_nil(found) assert_equal(1, found.length) end def test_find_by_css_with_escaped_characters found_without_escape = html.css("div[@id='abc.123']") found_by_id = html.css("#abc\\.123") found_by_class = html.css(".special\\.character") assert_equal(1, found_without_escape.length) assert_equal(found_by_id, found_without_escape) assert_equal(found_by_class, found_without_escape) end def test_find_with_function assert(html.css("div:awesome() h1", Class.new do def awesome(divs) [divs.first] end end.new)) end def test_dup_shallow found = html.search("//div/a").first dup = found.dup(0) assert(dup) assert_equal("", dup.content) end def test_search_can_handle_xpath_and_css found = html.search("//div/a", "div > p") length = html.xpath("//div/a").length + html.css("div > p").length assert_equal(length, found.length) end def test_dup_document assert(dup = html.dup) refute_equal(dup, html) assert_predicate(html, :html?) assert_instance_of(Nokogiri::HTML::Document, dup) assert_predicate(dup, :html?, "duplicate should be html") assert_equal(html.to_s, dup.to_s) end def test_dup_document_shallow assert(dup = html.dup(0)) refute_equal(dup, html) end def test_dup found = html.search("//div/a").first dup = found.dup assert(dup) assert_equal(found.content, dup.content) assert_equal(found.document, dup.document) end # issue 1060 def test_node_ownership_after_dup html = "

replace me

" doc = Nokogiri::HTML::Document.parse(html) dup = doc.dup assert_same(dup, dup.at_css("div").document) # should not raise an exception dup.at_css("div").parse("

replaced

") end def test_inner_html html = Nokogiri::HTML(<<~EOHTML)

Hello world!

EOHTML node = html.xpath("//div").first assert_equal("

Helloworld!

", node.inner_html.gsub(/\s/, "")) end def test_round_trip doc = Nokogiri::HTML(html.inner_html) assert_equal(html.root.to_html, doc.root.to_html) end def test_fragment_contains_text_node fragment = Nokogiri::HTML.fragment("fooo") assert_equal(1, fragment.children.length) assert_equal("fooo", fragment.inner_text) end def test_fragment_includes_two_tags assert_equal(2, Nokogiri::HTML.fragment("

").children.length) end def test_relative_css_finder doc = Nokogiri::HTML(<<~EOHTML)

inside red

inside green

EOHTML red_divs = doc.css("div.red") assert_equal(1, red_divs.length) p_tags = red_divs.first.css("p") assert_equal(1, p_tags.length) assert_equal("inside red", p_tags.first.text.strip) end def test_find_classes doc = Nokogiri::HTML(<<~EOHTML)

RED

GREEN

EOHTML list = doc.css(".red") assert_equal(2, list.length) assert_equal(["RED", "RED"], list.map(&:text)) end def test_parse_can_take_io html = nil File.open(HTML_FILE, "rb") do |f| html = Nokogiri::HTML(f) end assert_predicate(html, :html?) assert_equal(HTML_FILE, html.url) end def test_parse_works_with_an_object_that_responds_to_path html = +"hello" def html.path "/i/should/be/the/document/url" end doc = Nokogiri::HTML.parse(html) assert_equal("/i/should/be/the/document/url", doc.url) end # issue #1821, #2110 def test_parse_can_take_pathnames assert(File.size(HTML_FILE) > 4096) # file must be big enough to trip the read callback more than once doc = Nokogiri::HTML.parse(Pathname.new(HTML_FILE)) # an arbitrary assertion on the structure of the document assert_equal(166, doc.css("a").length) assert_equal(HTML_FILE, doc.url) end def test_html? refute_predicate(html, :xml?) assert_predicate(html, :html?) end def test_serialize assert(html.serialize) assert(html.to_html) end def test_empty_document # empty document should return "" #699 assert_equal("", Nokogiri::HTML.parse(nil).text) assert_equal("", Nokogiri::HTML.parse("").text) end def test_capturing_nonparse_errors_during_document_clone # see https://github.com/sparklemotion/nokogiri/issues/1196 for background original = Nokogiri::HTML.parse("

") original_errors = original.errors.dup copy = original.dup assert_equal(original_errors, copy.errors) end def test_capturing_nonparse_errors_during_node_copy_between_docs # Errors should be emitted while parsing only, and should not change when moving nodes. doc1 = Nokogiri::HTML("one") doc2 = Nokogiri::HTML("two") node1 = doc1.at_css("#unique") node2 = doc2.at_css("#unique") original_errors1 = doc1.errors.dup original_errors2 = doc2.errors.dup assert(original_errors1.any? { |e| e.to_s.include?("Tag diva invalid") }, "it should complain about the tag name") assert(original_errors2.any? { |e| e.to_s.include?("Tag dive invalid") }, "it should complain about the tag name") node1.add_child(node2) assert_equal(original_errors1, doc1.errors) assert_equal(original_errors2, doc2.errors) end def test_silencing_nonparse_errors_during_attribute_insertion_1262 # see https://github.com/sparklemotion/nokogiri/issues/1262 # # libxml2 emits a warning when this happens; the JRuby # implementation does not. so rather than capture the error in # doc.errors in a platform-dependent way, I'm opting to have # the error silenced. # # So this test doesn't look meaningful, but we want to avoid # having `ID unique-issue-1262 already defined` emitted to # stderr when running the test suite. # doc = Nokogiri::HTML::Document.new Nokogiri::XML::Element.new("div", doc).set_attribute("id", "unique-issue-1262") Nokogiri::XML::Element.new("div", doc).set_attribute("id", "unique-issue-1262") assert_equal(0, doc.errors.length) end def test_leaking_dtd_nodes_after_internal_subset_removal # see https://github.com/sparklemotion/nokogiri/issues/1784 # # just checking that this doesn't raise a valgrind error. we # don't otherwise have any test coverage for removing DTDs. # 100.times do |_i| Nokogiri::HTML::Document.new.internal_subset.remove end end it "skips encoding for script tags" do html = Nokogiri::HTML(<<~EOHTML) EOHTML node = html.xpath("//script").first assert_equal("var isGreater = 4 > 5;", node.inner_html) end it "skips encoding for style tags" do html = Nokogiri::HTML(<<~EOHTML) EOHTML node = html.xpath("//style").first assert_equal("tr > div { display:block; }", node.inner_html) end it "does not fail when converting to_html using explicit encoding" do html_fragment = <<~EOHTML

EOHTML doc = Nokogiri::HTML(html_fragment, nil, "ISO-8859-1") html = doc.to_html assert html.index("src=\"images/icon.gif\"") assert_equal "ISO-8859-1", html.encoding.name end it "handles ill-formed processing instructions" do html = %{= 2.10.0") [Nokogiri::XML::Node::COMMENT_NODE] else [] end assert_equal(expected, doc.at_css("body").children.map(&:type)) end describe ".parse" do let(:html_strict) do Nokogiri::XML::ParseOptions.new(Nokogiri::XML::ParseOptions::DEFAULT_HTML).norecover end it "sets the test up correctly" do assert_predicate(html_strict, :strict?) end describe "ill-formed < character" do let(:input) { %{

this < that

second element

} } it "skips to the next start tag" do # see https://github.com/sparklemotion/nokogiri/issues/2461 for why we're testing this edge case doc = Nokogiri::HTML4.parse(input) body = doc.at_xpath("//body") if Nokogiri.uses_libxml?("= 2.9.13") #

this

second element

assert_equal(1, body.children.length) body.children.first.tap do |div| assert_equal(2, div.children.length) assert_equal("this ", div.children[0].content) assert_equal("div", div.children[1].name) assert_equal("second element", div.children[1].content) end else #

this < that

second element

assert_equal(2, body.children.length) assert_equal(["div", "div"], body.children.map(&:name), body.to_html) assert_equal("this < that", body.children[0].text, body.to_html) assert_equal("second element", body.children[1].text, body.to_html) end end end describe "read memory" do let(:input) { ", 0) end end end describe "read io" do let(:input) { StringIO.new(", 0) end end end end describe "subclassing" do let(:klass) do Class.new(Nokogiri::HTML::Document) do attr_accessor :initialized_with, :initialized_count def initialize(*args) super @initialized_with = args @initialized_count ||= 0 @initialized_count += 1 end end end describe ".new" do it "returns an instance of the expected class" do doc = klass.new assert_instance_of(klass, doc) end it "calls #initialize exactly once" do doc = klass.new assert_equal(1, doc.initialized_count) end it "passes arguments to #initialize" do doc = klass.new("http://www.w3.org/TR/REC-html40/loose.dtd", "-//W3C//DTD HTML 4.0 Transitional//EN") assert_equal( ["http://www.w3.org/TR/REC-html40/loose.dtd", "-//W3C//DTD HTML 4.0 Transitional//EN"], doc.initialized_with ) end end it "#dup returns the expected class" do doc = klass.new.dup assert_instance_of(klass, doc) end describe ".parse" do it "returns an instance of the expected class" do doc = klass.parse(File.read(HTML_FILE)) assert_instance_of(klass, doc) end it "calls #initialize exactly once" do doc = klass.parse(File.read(HTML_FILE)) assert_equal(1, doc.initialized_count) end it "parses the doc" do doc = klass.parse(File.read(HTML_FILE)) assert_equal(html.root.to_s, doc.root.to_s) end end end end end end end