Question/Request: ability to access original arguments from within attribute blocks

[andrewhavens]

I'm trying to figure out how to solve an issue with circular dependencies. For example, I want to create a factory that accepts one of three associations. Whichever association is not provided would be created and associated with the one that was provided.

# pseudo example
factory :person do
  parent { create :parent }
  child { create :child, parent: parent }
  something { create :something, parent: parent }
end

# usage
create(:person, parent: parent)
create(:person, child: child)
create(:person, something: something)

The problem I'm running into is not knowing which of these values was passed originally in the call to create. It's also valid to pass nil in order to instantiate the model with a missing association.

I've tried doing this in after(:build), but I have no way of knowing if the association was nil or if it was created because it wasn't specified.

If there was some way to access the original arguments, then I could know which one was provided. Is there already a way to do this?

[CodeMeister]

Hi @andrewhavens ,

Circular dependencies can cause lot's of problems in your code, especially in migrations.

Generally, the relationship is defined in one table, and the reciprocal searched for in the other:

For example:
Assuming a person has only one parent, then you would add the parent_id attribute to the model, but not a child one. You can find the child by searching the persons table for a record with a matching parent_id.

In Rails, ActiveRecord does this automatically with associations:

class Person < ApplicationRecord
  belongs_to :parent, class_name: "Person"
  has_many :children, class_name: "Person", foreign_key: "parent_id"

If you really need the circular references, how about doing it with traits?

factory :person do
  trait :with_parent do
    after(:create) do |object|
      parent { create(:person, child: object)}
    end
  end

  trait :with_child do
    after(:create) do |object|
      child { create(:person, parent: object)}
    end
  end
end

This way, you only include the relationships you need: create(:person, :with_parent, :with_child)

Hope this helps 🤞

[andrewhavens]

@CodeMeister Thanks for the reply. However, that's not the problem I'm having. I probably didn't do a good job explaining. Let me try again...

In my application, there is a model that is associated with a lot of others. Kind of like a user model, but different. Let's call it Parent. I want my factory to build/create associations and make sure they are all associated with the same Parent record. One way I could do this is to always specify the parent. Like this:

create(:thing, parent: parent)
create(:thing, parent: parent, child: child)
create(:thing, parent: parent, something: something)

Then I could have a factory like this:

factory :thing do
  parent { create :parent }
  child { create :child, parent: parent }
  something { create :something, parent: parent }
end

But that's kind of annoying to have to specify the parent every time. I only really care that the "parent" is the same. I want to make specifying the parent optional, so I can do this:

create(:thing, parent: parent)
create(:thing, child: child)
create(:thing, something: something)

# in every case, this should be true
thing.parent == thing.child.parent == thing.something.parent

I could achieve that with something like this:

factory :thing do
  parent { nil }
  child { nil }
  something { nil}

  after(:build) do |thing|
    if thing.parent.nil? && thing.child.nil? && thing.something.nil?
      thing.parent = create :parent
    elsif thing.parent.nil?
      thing.parent = thing.child&.parent || thing.something&.parent
    end
    thing.child ||= create(:child, parent: thing.parent)
    thing.something ||= create(:something, parent: thing.parent)
  end
end

However, that doesn't work if I also want to support this:

create(:thing, parent: parent, something: nil)

thing.parent == thing.child.parent
thing.something == nil

In this case, I need to know if the original arguments to something was nil and/or if the parent was specified. Does this make sense?

[CodeMeister]

@andrewhavens I don't think you're going to get exactly what you want, but how about a combination of :after(:build) with traits?

factory :thing do
  after(:build) do |thing|
    thing.parent ||= thing.child.try(:partent) || thing.something.try(:parent) || create(:parent)
  end

  trait :with_child do
    after(:build) do |obj|
      obj.child = create(:child, parent: obj.parent)
    end
  end

  trait :with_something do
    after(:build) do |obj|
      obj.something = create(:something, parent: obj.parent)
    end
  end
end

This will let you create the following combinations:

• thing with no child or something: create(:thing, parent: parent)
• thing with generated child and no something: create(:thing, :with_child)
• thing with generated something and no child: create(:thing, :with_something)
• thing with both child & something: create(:thing, :with_child, :with_something)
• thing with existing child and no something: create(:thing, child: child)
• thing with existing child and generated something: create(:thing, :with_something, child: child)
• ... and so on

I'm sure you get the idea, and they will all have the same parent.

Parsing the user input would mean less typing in the tests, but that information's not available, without a chunk of work.

Let me know if I've understood the issue correctly this time 😊

[andrewhavens]

@CodeMeister I think you've mostly understood the issue, but this doesn't quite solve the problem. ☹️

In this example, parent, child, and something are default associations that need to be created/initialized unless intentionally nil'ed. So I should be able to do create(:thing) instead of having to do create(:thing, :with_parent, :with_child, :with_something).

I think I might have just thought of a solution to this though...

Instead of setting the association default value to nil, I could use transients with a non-nil value (true) to represent non-specified defaults. This would allow me to differentiate from an intentionally nil option and unspecified option. This is what I've come up with so far. It's way more verbose than I'd like but it is the only thing I've found so far that solves this issue since there doesn't seem to be a way to access the arguments/options from within the association/attribute blocks.

factory :thing do
  transient do
    parent { true }
    child { true }
    something { true }
  end

  after(:build) do |thing, evaluator|
    thing.parent = evaluator.parent if evaluator.parent.is_a?(Parent)
    thing.child = evaluator.child if evaluator.child.is_a?(Child)
    thing.something = evaluator.something if evaluator.something.is_a?(Something)

    if evaluator.parent == true
      thing.parent = thing.child&.parent || thing.something&.parent || create(:parent)
    end

    if evaluator.child == true
      thing.child = create(:child, parent: thing.parent)
    end

    if evaluator.something == true
      thing.something = create(:something, parent: thing.parent)
    end
  end
end

[CodeMeister]

@andrewhavens OK, got it...

You can use context.instance_variable_get(:@overrides) in the after(:build) callback to list the user provided attributes.

factory :thing do
  after(:build) do |thing, context|
    thing.parent ||= thing.child.try(:partent) || thing.something.try(:parent) || create(:parent)
    
    user_provided_attrs = context.instance_variable_get(:@overrides).keys
    
    unless user_provided_attrs.include(:child)
      thing.child = create(:child, parent: thing.parent)
    end
    
    unless user_provided_attrs.include(:thing)
      thing.something = create(:something, parent: thing.parent)
    end
  end
end

This way, :child and :something are only created if you have not directly set them to anything (even nil).

Let's hope this works for you 🤞