Rails: has_one and belongs_to with presence validation on both foreign keys

Question

I have an application with a users table and a user_profiles table. A user has_one user profile and a user profile belongs_to a user.

I want to make sure that the association scenario is always true, so I've put a validation for the presence of both foreign keys. The problem is that I hit a "chicken and egg" situation. When I create a user, it doesn't work because the user profile doesn't exist yet, and when I create a user profile, it doesn't work either because the user doesn't exist yet. So I need to create the user profile within the creation of the user. To complicate things, when I create a client, I also create a user in an after_create callback. Enough talking (or reading/writting), here is some code:

class User < ActiveRecord::Base
    has_one :user_profile
    validates :user_profile_id, presence: true
end

class UserProfile < ActiveRecord::Base
  belongs_to :user
  validates :user_id, presence: true
end

class Client < ActiveRecord::Base
  after_create :create_client_user

  private

  def create_client_user
    User.create!(
      email: "[email protected]",
      password: "admin",
      password_confirmation: "admin",
      client_id: self.id
      # I need to create a user profile dynamically here
    )
  end
end

Is it possible to do what I want to do?

Update

I tried the solution @cdesrosiers suggested, but I can't make my specs pass. I am mainly having three errors. First let me show you the updated models:

class User < ActiveRecord::Base
  has_one :user_profile, inverse_of: :user
  before_create { build_user_profile }

  validates :user_profile, presence: true

  def client=(client)
    self.client_id = client.id
  end

  def client
    current_database = Apartment::Database.current_database
    Apartment::Database.switch
    client = Client.find(self.client_id)
    Apartment::Database.switch(current_database)
    client
  end
end

class UserProfile < ActiveRecord::Base
  belongs_to :user

  validates :user, presence: true
end

class Client < ActiveRecord::Base
  attr_accessible :domain, :name

  after_create :create_client_database
  after_create :create_client_user
  after_destroy :drop_client_database

  # Create the client database (Apartment) for multi-tenancy
  def create_client_database
    Apartment::Database.create(self.domain)
  end

  # Create an admin user for the client
  def create_client_user
    Apartment::Database.switch(self.domain)

    User.create!(
      email: "[email protected]",
      password: "admin",
      password_confirmation: "admin",
      client: self
    )

    # Switch back to the public schema
    Apartment::Database.switch
  end

  def drop_client_database
    Apartment::Database.drop(self.domain)
  end
end

I am using FactoryGirl to create factories, here is my factories file:

FactoryGirl.define do
  factory :client do
    sequence(:domain) { |n| "client#{n}" }
    name              Faker::Company.name
  end

  factory :user do
    sequence(:email)      { |n| "user#{n}@example.com"}
    password              "password"
    password_confirmation "password"
    client
    #user_profile
  end

  factory :credentials, class: User do
    email       "[email protected]"
    password    "password"
  end

  factory :user_profile do
    forename       Faker::Name.first_name
    surname        Faker::Name.last_name
    birthday       (5..90).to_a.sample.years.ago
    #user
  end
end

If I uncomment the user_profile and user associations in the user and user profile factories respectively, I get a WARNING: out of shared memory.

Now, when I create one of those factories, I get one of those three errors:

Failure/Error: @user = create(:user)
     ActiveRecord::RecordInvalid:
       Validation failed: User profile A user profile is required
     # ./app/models/client.rb:41:in `create_client_user'
     # ./spec/controllers/users_controller_spec.rb:150:in `block (4 levels) in <top (required)>'

Failure/Error: create(:user_profile).should respond_to :surname
    ActiveRecord::RecordInvalid:
      Validation failed: User A user is required
    # ./spec/models/user_profile_spec.rb:29:in `block (4 levels) in <top (required)>'

Failure/Error: let(:client) { create(:client) }
     ActiveRecord::RecordInvalid:
       Validation failed: User profile A user profile is required
     # ./app/models/client.rb:41:in `create_client_user'
     # ./spec/controllers/sessions_controller_spec.rb:4:in `block (2 levels) in <top (required)>'
     # ./spec/controllers/sessions_controller_spec.rb:7:in `block (2 levels) in <top (required)>'

So I assume that the change in the User model didn't work. Also note that I removed the user_profile_id from the users table.

Ply

Answer 1

When model A has_one model B, this means that B stores the foreign key into A, in the same way that model C has_many model D means that D stores the foreign key into C. The has_one relation simply expresses your desire to allow only one record in B to hold a particular foreign key into A. Given that, you should get rid of user_profile_id from the users schema, because it isn't used. Only user_id from UserProfile is used.

You can still have User check for the presence of UserProfile, but use validates_presence_of :user_profile instead. This will check that the user object has an associated user_profile object.

Your UserProfile object should not check directly for a user_id since this id won't yet exist when creating a new user-user_profile pair. Instead use validates_presence_of :user, which will check that the UserProfile has an associated User object before saving it. Then write has_one :user_profile, :inverse_of => :user in User, which lets the UserProfile know about the presence of its User object, even before either has been persisted and assigned an id.

Finally, you can include a before_create block in User to build the associated UserProfile when creating a new user. (I believe) it will run validations after building a new user_profile, so these should pass.

In summary,

class User < ActiveRecord::Base
    has_one :user_profile, :inverse_of => :user
    validates_presence_of :user_profile

    before_create { build_user_profile }
end

class UserProfile < ActiveRecord::Base
  belongs_to :user
  validates_presence_of :user
end

---

UPDATE

I was mistaken about the validation-callback order. The validation runs before the before_create callback is called, which means User is checking for the presence of a UserProfile before one is even built.

One solution is to ask yourself what value you get from having separate user and user_profile models. Given that they are so tightly bound that one cannot exist without the other, would it make sense (and perhaps simplify a lot of your code) to just combine them into a single model?

On the other hand, if you really find that there is value in having two separate models, perhaps you shouldn't use validations to maintain their mutual existence. In my opinion, model validations should generally be used to let users know that the data they have submitted have errors they need to fix. However, the absence of a user_profile from their user object is not something they can fix. So, perhaps the better solution is to have the user object build a user_profile if there isn't one. Instead of just complaining if a user_profile doesn't exist, you take it a step further and just build it. No validation required on either side.

class User < ActiveRecord::Base
  has_one :user_profile

  before_save { build_user_profile unless user_profile }
end

class UserProfile < ActiveRecord::Base
  belongs_to :user
end

Backward

Thanks a lot for your answer, it made me update the code and the question itself. Unfortunately your solution didn't work for me for some reason. Please see the updated question for more details. – Ply

Thanks again for your answer. I updated my code, I combined the User and the UserProfile models. That change simplified my code greatly. – Ply

I think the callback that you wanted would be before_validation :build_user_profile, on: :create – Ormazd

Answer 2

You cannot validate the presence of user_profile_id because it does not exist. What has_one means is that the other model has a foreign key reference to it.

The way I generally ensure the behavior that you are after is by conditionally creating the model with the foreign key reference when the model being referenced is created. In your case that would be creating a profile after_create for the user like so:

class User < ActiveRecord::Base
  ...
  after_create :create_profile
  private
  def create_profile
    self.user_profile.create
  end
end

Sfumato

Answer 3

This rail cast goes over making nested forms, (to create both user/user_profile together). http://railscasts.com/episodes/196-nested-model-form-part-1 there is some modifications you need to do since it covers a has_many but you should be able to figure it out.

Jeromejeromy

Answer 4

You have a nesting problem here. It can be solved by nesting the form fields for user_profile on the user form and creating both at the same time.

class User
  accepts_nested_attributes_for :user_profile
  attr_accesible :user_profile_attributes
  validates_presence_of :user_profile_attributes

#user/new.haml
form_for @user do |f|
  fields_for @user.user_profile do |fields|
    fields.label "Etc"
    #......

http://api.rubyonrails.org/classes/ActionView/Helpers/FormHelper.html#method-i-fields_for

Waverley

This doesn't address the basically unresolvable problem of trying to validate the existences of a field that doesn't exist though. – Sfumato

validates_presence_of :user_profile_attributes ensures that the profile fields are there, and any validation under user_profile.rb will be run also, so you can't create an user without a profile. What do you mean? – Waverley