require 'spec_helper'
require 'virtus'

class Address
  include Virtus

  attribute :street, String
  attribute :zipcode, String
end
class Area
  include Virtus

  attribute :code, String
  attribute :iso, String  
end
class PhoneNumber
  include Virtus

  attribute :prefix, Integer
  attribute :number, String
  attribute :area, Area
end
class Person
  include Virtus

  attribute :id, String
  attribute :name, String
  attribute :address, Address

  def phone_numbers
    [PhoneNumber.new( 
        :prefix => 12, 
        :number => '123',
        :area => Area.new( :code => '001', :iso => 'us' )]
  end
  
  def age
    123
  end
end

describe Ixtlan::Babel::ModelFilter + ':with_methods' do
  let( :person ) do
   Person.new( :id => 987,
                         :name => 'me and the corner',
                         :address => Address.new( :street => 'Foo 12', :zipcode => '12345' ) )
  end

  let(:serializer) { Ixtlan::Babel::Serializer.new( person ) }
  let(:deserializer) { Ixtlan::Babel::Deserializer.new( Person ) }

  it 'should serialize and deserialize without root' do
    json = serializer.to_json
    result = deserializer.from_json(json)
    attributes = result.attributes.delete_if { |k,v| v.nil? }
    attributes.must_equal Hash[:id => person['id'], :name => person['name']]
  end

  it 'should serialize and deserialize with root' do
    json = serializer.to_json :root => :my
    result = deserializer.from_json(json, :root => :my)
    attributes = result.attributes.delete_if { |k,v| v.nil? }
    attributes.must_equal Hash[:id => person['id'], :name => person['name']]
  end  

  it 'should serialize and deserialize a hash with include list' do
    json = serializer.to_json(:include => ['address', 'phone_numbers']) 
    result = deserializer.from_json(json, :include => ['address', 'phone_numbers'])
    result.object_id.wont_equal person.object_id
    result.address.attributes.must_equal person.address.attributes
    result.phone_numbers[0].area.must_be_nil
    person.phone_numbers[0].area = nil
    result.phone_numbers[0].attributes.must_equal person.phone_numbers[0].attributes
    result.name.must_equal person.name
    result.id.must_equal person.id
  end

  it 'shouldserialize and deserialize with except' do
    json = serializer.to_json(:except => ['id'])  
    result = deserializer.from_json(json, :except => ['id'])  
    result.attributes.must_equal Hash[:name => person['name'], :address=>nil, :phone_numbers=>nil, :id => nil]
    result = deserializer.from_json(json)  
    result.attributes.must_equal Hash[:name => person['name'], :address=>nil, :phone_numbers=>nil, :id => nil]
  end

  it 'should serialize and deserialize with only' do
    json = serializer.to_json(:only => ['name']) 
    result = deserializer.from_json(json, :only => ['name'])
    result.attributes.must_equal Hash[:name => person['name'], :address=>nil, :phone_numbers=>nil, :id => nil]
    result = deserializer.from_json(json)
    result.attributes.must_equal Hash[:name => person['name'], :address=>nil, :phone_numbers=>nil, :id => nil]
  end

  it 'should serialize and deserialize with nested only' do
    json = serializer.to_json(:include => { 'address' => {:only => ['street']}})
    result = deserializer.from_json(json, :include => { 'address' => {:only => ['street']}})

    result.phone_numbers.must_be_nil
    result.phone_numbers = nil
    person.phone_numbers = nil

    result.address.zipcode.must_be_nil
    result.address.zipcode = nil
    person.address.zipcode = nil

    result.name.must_equal person.name
    result.id.must_equal person.id
  end

  it 'should serialize and deserialize with nested only (array includes)' do
    json = serializer.to_json(:include => { 'address' => {:only => ['street']}})
    result = deserializer.from_json(json, :include => ['address'])

    result.phone_numbers.must_be_nil
    result.phone_numbers = nil
    person.phone_numbers = nil

    result.address.zipcode.must_be_nil
    result.address.zipcode = nil
    person.address.zipcode = nil

    result.name.must_equal person.name
    result.id.must_equal person.id
  end

  it 'should serialize and deserialize with nested except' do
    json = serializer.to_json(:include => { 'address' => {:except => ['zipcode']}})
    result = deserializer.from_json(json, :include => { 'address' => {:except => ['zipcode']}})

    result.phone_numbers.must_be_nil
    result.phone_numbers = nil
    person.phone_numbers = nil

    result.address.zipcode.must_be_nil
    result.address.zipcode = nil
    person.address.zipcode = nil

    result.name.must_equal person.name
    result.id.must_equal person.id
  end

  it 'should serialize and deserialize with nested except (array includes)' do
    json = serializer.to_json(:include => { 'address' => {:except => ['zipcode']}})
    result = deserializer.from_json(json, :include => ['address'])

    result.phone_numbers.must_be_nil
    result.phone_numbers = nil
    person.phone_numbers = nil

    result.address.zipcode.must_be_nil
    result.address.zipcode = nil
    person.address.zipcode = nil

    result.name.must_equal person.name
    result.id.must_equal person.id
  end

  it 'should serialize and deserialize with nested include' do
    json = serializer.to_json(:include => { 'address' => {}, 'phone_numbers' => { :include => ['area']}}) 
    result = deserializer.from_json(json, :include => { 'address' => {}, 'phone_numbers' => { :include => ['area']}})

    result.object_id.wont_equal person.object_id
    result.address.attributes.must_equal person.address.attributes
    result.phone_numbers[0].area.attributes.must_equal person.phone_numbers[0].area.attributes
    result.phone_numbers[0].prefix.must_equal person.phone_numbers[0].prefix
    result.phone_numbers[0].number.must_equal person.phone_numbers[0].number
    result.name.must_equal person.name
    result.id.must_equal person.id
  end
end