class Contact < ActiveRecord::Base
  include Searchable
  include Filterable
  include BranchManager

  belongs_to :location
  has_one :user
  has_many :emails, as: :of
  has_many :phones, as: :of
  accepts_nested_attributes_for :emails, allow_destroy: true
  accepts_nested_attributes_for :phones, allow_destroy: true

  enum type_user: {salesRep: 0, accountant: 1}
  scope :sales_rep, -> {where(:type_user => ContactType::SALESREP)}

  validates_presence_of :name, :type_user, :emails, :phones

  def self.for_select
    all.pluck(:id,:name)
  end

  def self.sales_rep_for_select
    sales_rep.for_select
  end

  def email
    ( emails.empty? )? "n/h" : emails.first.email;
  end

  def roles_for_users
    (location)? location.roles : []
  end
end

require 'spec_helper'

describe Contact, :type => :model do
  let(:email){ build(:email) }
  let(:phone){ build(:phone) }
  let(:contact){ build(:contact, emails: [email], phones: [phone]) }
  subject{ contact }

  it{ is_expected.to respond_to(:name)}
  it{ is_expected.to respond_to(:title)}
  it{ is_expected.to respond_to(:role)}
  it{ is_expected.to respond_to(:type_user)}
  it{ is_expected.to respond_to(:birthday)}
  it{ is_expected.to respond_to(:status)}
  it{ is_expected.to respond_to(:created_at)}
  it{ is_expected.to respond_to(:updated_at)}

  it{ expect(contact.emails).to include(email)}
  it{ expect(contact.phones).to include(phone)}

  describe 'validation' do
    it{ is_expected.to validate_presence_of(:name)  }
    it{ is_expected.to validate_presence_of(:type_user)  }
    it{ is_expected.to validate_presence_of(:emails)  }
    it{ is_expected.to validate_presence_of(:phones)  }
  end

  context 'with optional relation' do
    let(:location){ build(:location) }
    let(:user){ build(:user) }

    describe 'location' do
      before{ contact.location = location }
      it{ expect(contact.location).to be(location)  }
    end

    describe 'user' do
      before{ contact.user = user }
      it{ expect(contact.user).to be(user)  }
    end
  end

  context 'create' do
    describe 'multiple roles' do
      let(:attributes){ attributes_for(:contact) }
      it do
        expect{create(:contact, attributes ) }.to change(Contact, :count).by(1)
      end
    end

    describe 'accepts_nested_attributes' do
      describe 'contacts' do
        let(:attributes){attributes_for(:contact, emails:[],phones:[],emails_attributes: [attributes_for(:email)] ,phones_attributes: [attributes_for(:phone)])}
        it { expect{Contact.new(attributes)}.to_not raise_error }
      end
    end
  end
end