如何建立工厂女孩协会？

Question

我有麻烦建立协会。我有我的模型定义如下：

class Conversation 
    belongs_to :user1 
    belongs_to :user2 
    has_many :messages 
end 

和我现在我试图像创建工厂“conversation_with_messages”定义这些工厂

factory :user do 
    name "name" 
end 

factory :female, parent: :user do 
    gender 'f' 
end 

factory :male, parent: :user do 
    gender 'm' 
end 

factory :message do 
    message "message" 
    conversation 
end 

这

factory :conversation do 
    read false 
    association :user1, factory: :male 
    association :user2, factory: :female  
    factory :conversation_with_messages do 

     ignore do 
     messages_count 10 
     end 

     after(:create) do |conversation, evaluator| 
     FactoryGirl.create_list(:message, evaluator.messages_count, author: conversation.user1) 
     end 
    end 
    end 

但如果FactoryGirl.create(:conversation_with_messages)给出数据库错误，说明user1_id列需要不为空。

我想知道为什么这个专栏没有填写，我在这里做错了什么？

Answer 1

您是否在对话模型关系中指定了class_name？

class Conversation 
    belongs_to :user1, class_name: 'User' 
    belongs_to :user2, class_name: 'User' 
    has_many :messages 
end 

Answer 2

当测试很难时，考虑修改您的设计。两个想法涌现在脑海里：

1）MUSTUser■找多个Conversation S'

如果类似Twitter的直接消息模型（任意两个用户之间的一个连续的谈话）是可以接受的，那么你可以去的东西，如：

class Message < ActiveRecord::Base 
    belongs_to :sender, class_name: 'User' 
    belongs_to :recipient, class_name: 'User' 

    default_scope order("created_at DESC") 

    def read? 
    !self.unread? 
    end 

    def read_or_unread 
    self.unread? ? "unread" : "read" 
    end 
end 

class User < ActiveRecord::Base 
    has_many :messages, foreign_key: :recipient_id 

    def messages_grouped_by_sender 
    msg_ids = messages.select("MAX(id) AS id").group(:sender_id).collect(&:id) 
    Message.includes(:sender).where(id: msg_ids) 
    end 
end 

class Conversation 

    THEM_TO_ME = "sender_id = :their_id AND recipient_id = :my_id" 
    ME_TO_THEM = "sender_id = :my_id AND recipient_id = :their_id" 

    def initialize(me, them) 
    @me = me 
    @them = them 
    end 

    def them 
    @them 
    end 

    def thread 
    Message.where("#{ME_TO_THEM} OR #{THEM_TO_ME}", ids) 
    end 

    def unread? 
    # Checking only the newest message is good enough 
    messages_to_me.first.try(:unread) 
    end 

    def mark_as_read 
    messages_to_me.where(:unread => true).update_all(:unread => false) 
    end 

    def to_or_from_me(message) 
    message.sender == @me ? "From" : "To" 
    end 

    private 

    def messages_to_me 
    Message.where(THEM_TO_ME, ids) 
    end 

    def ids 
    { :my_id => @me.id, :their_id => @them.id } 
    end 
end 

2）不要Conversation的需要被保留到数据库？

如果Message看起来像以下，那么你可以采取一个消息，那么以前的信息链以下初始化一个Conversation。

class Message < ActiveRecord::Base 
    belongs_to :sender, class_name: 'User' 
    belongs_to :recipient, class_name: 'User' 
    belongs_to :previous_message, class_name: 'Message' 
end 

class Conversation 
    def initialize(message) 
    @message = message 
    end 

    def messages 
    //use @message to follow the chain of messages 
    end 
end