Class SerializationTest < ActiveModel::TestCase

# File activerecord/test/cases/serialization_test.rb, line 13
def setup
  @contact_attributes = {
    :name           => 'aaron stack',
    :age            => 25,
    :avatar         => 'binarydata',
    :created_at     => Time.utc(2006, 8, 1),
    :awesome        => false,
    :preferences    => { :gem => '<strong>ruby</strong>' },
    :alternative_id => nil,
    :id             => nil
  }
end

# File activemodel/test/cases/serialization_test.rb, line 154
def test_except_include
  expected = {"name"=>"David", "email"=>"david@example.com",
              "friends"=> [{"name" => 'Joe', "email" => 'joe@example.com'},
                           {"name" => "Sue", "email" => 'sue@example.com'}]}
  assert_equal expected, @user.serializable_hash(except: :gender, include: { friends: { except: :gender } })
end

# File activerecord/test/cases/serialization_test.rb, line 98
def test_find_records_by_serialized_attributes_through_join
  author = Author.create!(name: "David")
  author.serialized_posts.create!(title: "Hello")

  assert_equal 1, Author.joins(:serialized_posts).where(name: "David", serialized_posts: { title: "Hello" }).length
end

# File activemodel/test/cases/serialization_test.rb, line 118
def test_include_option_with_ary
  @user.friends = FriendList.new(@user.friends)
  expected = {"email"=>"david@example.com", "gender"=>"male", "name"=>"David",
              "friends"=>[{"name"=>'Joe', "email"=>'joe@example.com', "gender"=>'male'},
                         {"name"=>'Sue', "email"=>'sue@example.com', "gender"=>'female'}]}
  assert_equal expected, @user.serializable_hash(include: :friends)
end

# File activemodel/test/cases/serialization_test.rb, line 102
def test_include_option_with_empty_association
  @user.friends = []
  expected = {"email"=>"david@example.com", "gender"=>"male", "name"=>"David", "friends"=>[]}
  assert_equal expected, @user.serializable_hash(include: :friends)
end

# File activemodel/test/cases/serialization_test.rb, line 95
def test_include_option_with_plural_association
  expected = {"email"=>"david@example.com", "gender"=>"male", "name"=>"David",
              "friends"=>[{"name"=>'Joe', "email"=>'joe@example.com', "gender"=>'male'},
                         {"name"=>'Sue', "email"=>'sue@example.com', "gender"=>'female'}]}
  assert_equal expected, @user.serializable_hash(include: :friends)
end

# File activemodel/test/cases/serialization_test.rb, line 89
def test_include_option_with_singular_association
  expected = {"name"=>"David", "gender"=>"male", "email"=>"david@example.com",
              "address"=>{"street"=>"123 Lane", "city"=>"Springfield", "state"=>"CA", "zip"=>11111}}
  assert_equal expected, @user.serializable_hash(include: :address)
end

# File activerecord/test/cases/serialization_test.rb, line 58
def test_include_root_in_json_allows_inheritance
  original_root_in_json = ActiveRecord::Base.include_root_in_json
  ActiveRecord::Base.include_root_in_json = true

  klazz = Class.new(ActiveRecord::Base)
  klazz.table_name = 'topics'
  assert klazz.include_root_in_json

  klazz.include_root_in_json = false
  assert ActiveRecord::Base.include_root_in_json
  assert !klazz.include_root_in_json
  assert !klazz.new.include_root_in_json
ensure
  ActiveRecord::Base.include_root_in_json = original_root_in_json
end

# File activerecord/test/cases/serialization_test.rb, line 26
def test_include_root_in_json_is_false_by_default
  assert_equal false, ActiveRecord::Base.include_root_in_json, "include_root_in_json should be false by default but was not"
end

# File activemodel/test/cases/serialization_test.rb, line 134
def test_include_with_options
  expected = {"email"=>"david@example.com", "gender"=>"male", "name"=>"David",
              "address"=>{"street"=>"123 Lane"}}
  assert_equal expected, @user.serializable_hash(include: { address: { only: "street" } })
end

# File activemodel/test/cases/serialization_test.rb, line 45
def test_method_serializable_hash_should_work
  expected = {"name"=>"David", "gender"=>"male", "email"=>"david@example.com"}
  assert_equal expected, @user.serializable_hash
end

# File activemodel/test/cases/serialization_test.rb, line 70
def test_method_serializable_hash_should_work_with_except_and_methods
  expected = {"gender"=>"male", "foo"=>"i_am_foo"}
  assert_equal expected, @user.serializable_hash(except: [:name, :email], methods: [:foo])
end

# File activemodel/test/cases/serialization_test.rb, line 55
def test_method_serializable_hash_should_work_with_except_option
  expected = {"gender"=>"male", "email"=>"david@example.com"}
  assert_equal expected, @user.serializable_hash(except: [:name])
end

# File activemodel/test/cases/serialization_test.rb, line 60
def test_method_serializable_hash_should_work_with_methods_option
  expected = {"name"=>"David", "gender"=>"male", "foo"=>"i_am_foo", "email"=>"david@example.com"}
  assert_equal expected, @user.serializable_hash(methods: [:foo])
end

# File activemodel/test/cases/serialization_test.rb, line 65
def test_method_serializable_hash_should_work_with_only_and_methods
  expected = {"foo"=>"i_am_foo"}
  assert_equal expected, @user.serializable_hash(only: [], methods: [:foo])
end

# File activemodel/test/cases/serialization_test.rb, line 50
def test_method_serializable_hash_should_work_with_only_option
  expected = {"name"=>"David"}
  assert_equal expected, @user.serializable_hash(only: [:name])
end

# File activemodel/test/cases/serialization_test.rb, line 126
def test_multiple_includes
  expected = {"email"=>"david@example.com", "gender"=>"male", "name"=>"David",
              "address"=>{"street"=>"123 Lane", "city"=>"Springfield", "state"=>"CA", "zip"=>11111},
              "friends"=>[{"name"=>'Joe', "email"=>'joe@example.com', "gender"=>'male'},
                         {"name"=>'Sue', "email"=>'sue@example.com', "gender"=>'female'}]}
  assert_equal expected, @user.serializable_hash(include: [:address, :friends])
end

# File activemodel/test/cases/serialization_test.rb, line 161
def test_multiple_includes_with_options
  expected = {"email"=>"david@example.com", "gender"=>"male", "name"=>"David",
              "address"=>{"street"=>"123 Lane"},
              "friends"=>[{"name"=>'Joe', "email"=>'joe@example.com', "gender"=>'male'},
                         {"name"=>'Sue', "email"=>'sue@example.com', "gender"=>'female'}]}
  assert_equal expected, @user.serializable_hash(include: [{ address: {only: "street" } }, :friends])
end

# File activemodel/test/cases/serialization_test.rb, line 140
def test_nested_include
  @user.friends.first.friends = [@user]
  expected = {"email"=>"david@example.com", "gender"=>"male", "name"=>"David",
              "friends"=>[{"name"=>'Joe', "email"=>'joe@example.com', "gender"=>'male',
                          "friends"=> [{"email"=>"david@example.com", "gender"=>"male", "name"=>"David"}]},
                          {"name"=>'Sue', "email"=>'sue@example.com', "gender"=>'female', "friends"=> []}]}
  assert_equal expected, @user.serializable_hash(include: { friends: { include: :friends } })
end

# File activemodel/test/cases/serialization_test.rb, line 149
def test_only_include
  expected = {"name"=>"David", "friends" => [{"name" => "Joe"}, {"name" => "Sue"}]}
  assert_equal expected, @user.serializable_hash(only: :name, include: { friends: { only: :name } })
end

# File activerecord/test/cases/serialization_test.rb, line 90
def test_read_attribute_for_serialization_with_format_after_find
  klazz = Class.new(ActiveRecord::Base)
  klazz.table_name = 'books'

  book = klazz.find(books(:awdr).id)
  assert_equal 'paperback', book.read_attribute_for_serialization(:format)
end

# File activerecord/test/cases/serialization_test.rb, line 82
def test_read_attribute_for_serialization_with_format_after_init
  klazz = Class.new(ActiveRecord::Base)
  klazz.table_name = 'books'

  book = klazz.new(format: 'paperback')
  assert_equal 'paperback', book.read_attribute_for_serialization(:format)
end

# File activerecord/test/cases/serialization_test.rb, line 74
def test_read_attribute_for_serialization_with_format_without_method_missing
  klazz = Class.new(ActiveRecord::Base)
  klazz.table_name = 'books'

  book = klazz.new
  assert_nil book.read_attribute_for_serialization(:format)
end

# File activerecord/test/cases/serialization_test.rb, line 48
def test_serialize_should_allow_attribute_except_filtering
  FORMATS.each do |format|
    @serialized = Contact.new(@contact_attributes).send("to_#{format}", :except => [ :age, :name ])
    contact = Contact.new.send("from_#{format}", @serialized)
    assert_nil contact.name, "For #{format}"
    assert_nil contact.age, "For #{format}"
    assert_equal @contact_attributes[:awesome], contact.awesome, "For #{format}"
  end
end

# File activerecord/test/cases/serialization_test.rb, line 39
def test_serialize_should_allow_attribute_only_filtering
  FORMATS.each do |format|
    @serialized = Contact.new(@contact_attributes).send("to_#{format}", :only => [ :age, :name ])
    contact = Contact.new.send("from_#{format}", @serialized)
    assert_equal @contact_attributes[:name], contact.name, "For #{format}"
    assert_nil contact.avatar, "For #{format}"
  end
end

# File activerecord/test/cases/serialization_test.rb, line 30
def test_serialize_should_be_reversible
  FORMATS.each do |format|
    @serialized = Contact.new.send("to_#{format}")
    contact = Contact.new.send("from_#{format}", @serialized)

    assert_equal @contact_attributes.keys.collect(&:to_s).sort, contact.attributes.keys.collect(&:to_s).sort, "For #{format}"
  end
end

# File activemodel/test/cases/serialization_test.rb, line 75
def test_should_not_call_methods_that_dont_respond
  expected = {"name"=>"David", "gender"=>"male", "email"=>"david@example.com"}
  assert_equal expected, @user.serializable_hash(methods: [:bar])
end

# File activemodel/test/cases/serialization_test.rb, line 80
def test_should_use_read_attribute_for_serialization
  def @user.read_attribute_for_serialization(n)
    "Jon"
  end

  expected = { "name" => "Jon" }
  assert_equal expected, @user.serializable_hash(only: :name)
end