241 lines
8.1 KiB
Ruby
241 lines
8.1 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require_relative "../../abstract_unit"
|
|
require "active_support/core_ext/array"
|
|
require "active_support/core_ext/big_decimal"
|
|
require "active_support/core_ext/hash"
|
|
require "active_support/core_ext/string"
|
|
|
|
class ToSentenceTest < ActiveSupport::TestCase
|
|
def test_plain_array_to_sentence
|
|
assert_equal "", [].to_sentence
|
|
assert_equal "one", ["one"].to_sentence
|
|
assert_equal "one and two", ["one", "two"].to_sentence
|
|
assert_equal "one, two, and three", ["one", "two", "three"].to_sentence
|
|
end
|
|
|
|
def test_to_sentence_with_words_connector
|
|
assert_equal "one two, and three", ["one", "two", "three"].to_sentence(words_connector: " ")
|
|
assert_equal "one & two, and three", ["one", "two", "three"].to_sentence(words_connector: " & ")
|
|
assert_equal "onetwo, and three", ["one", "two", "three"].to_sentence(words_connector: nil)
|
|
end
|
|
|
|
def test_to_sentence_with_last_word_connector
|
|
assert_equal "one, two, and also three", ["one", "two", "three"].to_sentence(last_word_connector: ", and also ")
|
|
assert_equal "one, twothree", ["one", "two", "three"].to_sentence(last_word_connector: nil)
|
|
assert_equal "one, two three", ["one", "two", "three"].to_sentence(last_word_connector: " ")
|
|
assert_equal "one, two and three", ["one", "two", "three"].to_sentence(last_word_connector: " and ")
|
|
end
|
|
|
|
def test_two_elements
|
|
assert_equal "one and two", ["one", "two"].to_sentence
|
|
assert_equal "one two", ["one", "two"].to_sentence(two_words_connector: " ")
|
|
end
|
|
|
|
def test_one_element
|
|
assert_equal "one", ["one"].to_sentence
|
|
end
|
|
|
|
def test_one_element_not_same_object
|
|
elements = ["one"]
|
|
assert_not_equal elements[0].object_id, elements.to_sentence.object_id
|
|
end
|
|
|
|
def test_one_non_string_element
|
|
assert_equal "1", [1].to_sentence
|
|
end
|
|
|
|
def test_does_not_modify_given_hash
|
|
options = { words_connector: " " }
|
|
assert_equal "one two, and three", ["one", "two", "three"].to_sentence(options)
|
|
assert_equal({ words_connector: " " }, options)
|
|
end
|
|
|
|
def test_with_blank_elements
|
|
assert_equal ", one, , two, and three", [nil, "one", "", "two", "three"].to_sentence
|
|
end
|
|
|
|
def test_with_invalid_options
|
|
exception = assert_raise ArgumentError do
|
|
["one", "two"].to_sentence(passing: "invalid option")
|
|
end
|
|
|
|
assert_equal "Unknown key: :passing. Valid keys are: :words_connector, :two_words_connector, :last_word_connector, :locale", exception.message
|
|
end
|
|
|
|
def test_always_returns_string
|
|
assert_instance_of String, [ActiveSupport::SafeBuffer.new("one")].to_sentence
|
|
assert_instance_of String, [ActiveSupport::SafeBuffer.new("one"), "two"].to_sentence
|
|
assert_instance_of String, [ActiveSupport::SafeBuffer.new("one"), "two", "three"].to_sentence
|
|
end
|
|
|
|
def test_returns_no_frozen_string
|
|
assert_not [].to_sentence.frozen?
|
|
assert_not ["one"].to_sentence.frozen?
|
|
assert_not ["one", "two"].to_sentence.frozen?
|
|
assert_not ["one", "two", "three"].to_sentence.frozen?
|
|
end
|
|
end
|
|
|
|
class ToSTest < ActiveSupport::TestCase
|
|
class TestDB
|
|
def self.reset
|
|
@@counter = 0
|
|
end
|
|
|
|
reset
|
|
|
|
def id
|
|
@@counter += 1
|
|
end
|
|
end
|
|
|
|
setup do
|
|
TestDB.reset
|
|
end
|
|
|
|
def test_to_s_db
|
|
collection = [TestDB.new, TestDB.new, TestDB.new]
|
|
|
|
assert_deprecated do
|
|
assert_equal "null", [].to_s(:db)
|
|
end
|
|
assert_deprecated do
|
|
assert_equal "1,2,3", collection.to_s(:db)
|
|
end
|
|
end
|
|
|
|
def test_to_s_not_existent
|
|
assert_deprecated do
|
|
assert_equal "[]", [].to_s(:not_existent)
|
|
end
|
|
end
|
|
|
|
def test_to_fs_db
|
|
collection = [TestDB.new, TestDB.new, TestDB.new]
|
|
|
|
assert_equal "null", [].to_fs(:db)
|
|
assert_equal "1,2,3", collection.to_fs(:db)
|
|
assert_equal "null", [].to_formatted_s(:db)
|
|
assert_equal "4,5,6", collection.to_formatted_s(:db)
|
|
end
|
|
end
|
|
|
|
class ToXmlTest < ActiveSupport::TestCase
|
|
def test_to_xml_with_hash_elements
|
|
xml = [
|
|
{ name: "David", age: 26, age_in_millis: 820497600000 },
|
|
{ name: "Jason", age: 31, age_in_millis: BigDecimal("1.0") }
|
|
].to_xml(skip_instruct: true, indent: 0)
|
|
|
|
assert_equal '<objects type="array"><object>', xml.first(30)
|
|
assert_includes xml, %(<age type="integer">26</age>), xml
|
|
assert_includes xml, %(<age-in-millis type="integer">820497600000</age-in-millis>), xml
|
|
assert_includes xml, %(<name>David</name>), xml
|
|
assert_includes xml, %(<age type="integer">31</age>), xml
|
|
assert_includes xml, %(<age-in-millis type="decimal">1.0</age-in-millis>), xml
|
|
assert_includes xml, %(<name>Jason</name>), xml
|
|
end
|
|
|
|
def test_to_xml_with_non_hash_elements
|
|
xml = %w[1 2 3].to_xml(skip_instruct: true, indent: 0)
|
|
|
|
assert_equal '<strings type="array"><string', xml.first(29)
|
|
assert_includes xml, %(<string>2</string>), xml
|
|
end
|
|
|
|
def test_to_xml_with_non_hash_different_type_elements
|
|
xml = [1, 2.0, "3"].to_xml(skip_instruct: true, indent: 0)
|
|
|
|
assert_equal '<objects type="array"><object', xml.first(29)
|
|
assert_includes xml, %(<object type="integer">1</object>), xml
|
|
assert_includes xml, %(<object type="float">2.0</object>), xml
|
|
assert_includes xml, %(object>3</object>), xml
|
|
end
|
|
|
|
def test_to_xml_with_dedicated_name
|
|
xml = [
|
|
{ name: "David", age: 26, age_in_millis: 820497600000 }, { name: "Jason", age: 31 }
|
|
].to_xml(skip_instruct: true, indent: 0, root: "people")
|
|
|
|
assert_equal '<people type="array"><person>', xml.first(29)
|
|
end
|
|
|
|
def test_to_xml_with_options
|
|
xml = [
|
|
{ name: "David", street_address: "Paulina" }, { name: "Jason", street_address: "Evergreen" }
|
|
].to_xml(skip_instruct: true, skip_types: true, indent: 0)
|
|
|
|
assert_equal "<objects><object>", xml.first(17)
|
|
assert_includes xml, %(<street-address>Paulina</street-address>)
|
|
assert_includes xml, %(<name>David</name>)
|
|
assert_includes xml, %(<street-address>Evergreen</street-address>)
|
|
assert_includes xml, %(<name>Jason</name>)
|
|
end
|
|
|
|
def test_to_xml_with_indent_set
|
|
xml = [
|
|
{ name: "David", street_address: "Paulina" }, { name: "Jason", street_address: "Evergreen" }
|
|
].to_xml(skip_instruct: true, skip_types: true, indent: 4)
|
|
|
|
assert_equal "<objects>\n <object>", xml.first(22)
|
|
assert_includes xml, %(\n <street-address>Paulina</street-address>)
|
|
assert_includes xml, %(\n <name>David</name>)
|
|
assert_includes xml, %(\n <street-address>Evergreen</street-address>)
|
|
assert_includes xml, %(\n <name>Jason</name>)
|
|
end
|
|
|
|
def test_to_xml_with_dasherize_false
|
|
xml = [
|
|
{ name: "David", street_address: "Paulina" }, { name: "Jason", street_address: "Evergreen" }
|
|
].to_xml(skip_instruct: true, skip_types: true, indent: 0, dasherize: false)
|
|
|
|
assert_equal "<objects><object>", xml.first(17)
|
|
assert_includes xml, %(<street_address>Paulina</street_address>)
|
|
assert_includes xml, %(<street_address>Evergreen</street_address>)
|
|
end
|
|
|
|
def test_to_xml_with_dasherize_true
|
|
xml = [
|
|
{ name: "David", street_address: "Paulina" }, { name: "Jason", street_address: "Evergreen" }
|
|
].to_xml(skip_instruct: true, skip_types: true, indent: 0, dasherize: true)
|
|
|
|
assert_equal "<objects><object>", xml.first(17)
|
|
assert_includes xml, %(<street-address>Paulina</street-address>)
|
|
assert_includes xml, %(<street-address>Evergreen</street-address>)
|
|
end
|
|
|
|
def test_to_xml_with_instruct
|
|
xml = [
|
|
{ name: "David", age: 26, age_in_millis: 820497600000 },
|
|
{ name: "Jason", age: 31, age_in_millis: BigDecimal("1.0") }
|
|
].to_xml(skip_instruct: false, indent: 0)
|
|
|
|
assert_match(/^<\?xml [^>]*/, xml)
|
|
assert_equal 0, xml.rindex(/<\?xml /)
|
|
end
|
|
|
|
def test_to_xml_with_block
|
|
xml = [
|
|
{ name: "David", age: 26, age_in_millis: 820497600000 },
|
|
{ name: "Jason", age: 31, age_in_millis: BigDecimal("1.0") }
|
|
].to_xml(skip_instruct: true, indent: 0) do |builder|
|
|
builder.count 2
|
|
end
|
|
|
|
assert_includes xml, %(<count>2</count>), xml
|
|
end
|
|
|
|
def test_to_xml_with_empty
|
|
xml = [].to_xml
|
|
assert_match(/type="array"\/>/, xml)
|
|
end
|
|
|
|
def test_to_xml_dups_options
|
|
options = { skip_instruct: true }
|
|
[].to_xml(options)
|
|
# :builder, etc, shouldn't be added to options
|
|
assert_equal({ skip_instruct: true }, options)
|
|
end
|
|
end
|