anima-core 0.3.0 → 1.0.0

data/skills/rspec/examples/factory_bot/associations.rb

@@ -0,0 +1,314 @@
+# FactoryBot: Associations Examples
+# Source: factory_bot gem spec/acceptance/associations_spec.rb
+
+# Associations create related records automatically.
+# Strategy propagates: build creates built associations,
+# create creates persisted associations.
+
+# Implicit belongs_to
+FactoryBot.define do
+  factory :user do
+    name { "John" }
+  end
+
+  factory :post do
+    title { "My Post" }
+    user  # Implicit - looks for :user factory
+  end
+end
+
+RSpec.describe "Implicit associations" do
+  describe "belongs_to" do
+    let(:post) { build(:post) }
+
+    it "creates associated record" do
+      expect(post.user).to be_present
+      expect(post.user.name).to eq("John")
+    end
+  end
+end
+
+# Explicit association syntax
+FactoryBot.define do
+  factory :comment do
+    body { "Comment text" }
+    association :author, factory: :user
+  end
+
+  factory :review do
+    content { "Review content" }
+    association :reviewer, factory: :user, name: "Reviewer"
+  end
+end
+
+RSpec.describe "Explicit associations" do
+  describe "with factory option" do
+    let(:comment) { build(:comment) }
+
+    it "uses specified factory" do
+      expect(comment.author).to be_a(User)
+    end
+  end
+
+  describe "with attribute overrides" do
+    let(:review) { build(:review) }
+
+    it "applies overrides to association" do
+      expect(review.reviewer.name).to eq("Reviewer")
+    end
+  end
+end
+
+# Association with traits
+FactoryBot.define do
+  factory :admin_post, class: "Post" do
+    title { "Admin Post" }
+    association :author, factory: [:user, :admin]
+  end
+
+  factory :featured_article, class: "Article" do
+    title { "Featured" }
+    association :author, :verified, factory: :user
+  end
+end
+
+RSpec.describe "Association with traits" do
+  describe "array syntax for factory with traits" do
+    let(:post) { build(:admin_post) }
+
+    it "applies traits to associated record" do
+      expect(post.author).to be_admin
+    end
+  end
+
+  describe "inline trait syntax" do
+    let(:article) { build(:featured_article) }
+
+    it "applies trait to association" do
+      expect(article.author).to be_verified
+    end
+  end
+end
+
+# Strategy inheritance
+RSpec.describe "Strategy inheritance" do
+  FactoryBot.define do
+    factory :post do
+      title { "Post" }
+      user
+    end
+  end
+
+  describe "build inherits to associations" do
+    let(:post) { build(:post) }
+
+    it "builds association (not persisted)" do
+      expect(post).to be_new_record
+      expect(post.user).to be_new_record
+    end
+  end
+
+  describe "create inherits to associations" do
+    let(:post) { create(:post) }
+
+    it "creates association (persisted)" do
+      expect(post).to be_persisted
+      expect(post.user).to be_persisted
+    end
+  end
+
+  describe "build_stubbed inherits to associations" do
+    let(:post) { build_stubbed(:post) }
+
+    it "stubs association" do
+      expect(post).to be_persisted
+      expect(post.user).to be_persisted
+    end
+  end
+end
+
+# Override strategy for association
+FactoryBot.define do
+  factory :post do
+    title { "Post" }
+    association :user, strategy: :create  # Always create user
+  end
+end
+
+RSpec.describe "Strategy override" do
+  describe "explicit strategy on association" do
+    let(:post) { build(:post) }
+
+    it "uses specified strategy regardless of parent" do
+      expect(post).to be_new_record
+      expect(post.user).to be_persisted  # Created due to strategy: :create
+    end
+  end
+end
+
+# has_many associations
+FactoryBot.define do
+  factory :blog do
+    name { "My Blog" }
+    posts { [association(:post)] }
+  end
+
+  factory :author do
+    name { "Author" }
+    articles { Array.new(3) { association(:article) } }
+  end
+end
+
+RSpec.describe "has_many associations" do
+  describe "inline collection" do
+    let(:blog) { build(:blog) }
+
+    it "creates collection with one item" do
+      expect(blog.posts.length).to eq(1)
+    end
+  end
+
+  describe "multiple items" do
+    let(:author) { build(:author) }
+
+    it "creates specified number of items" do
+      expect(author.articles.length).to eq(3)
+    end
+  end
+end
+
+# has_many with transient attributes
+FactoryBot.define do
+  factory :user do
+    name { "User" }
+
+    transient do
+      posts_count { 0 }
+    end
+
+    after(:create) do |user, evaluator|
+      create_list(:post, evaluator.posts_count, author: user)
+      user.reload
+    end
+  end
+end
+
+RSpec.describe "has_many with transient" do
+  describe "configurable collection size" do
+    let(:user) { create(:user, posts_count: 5) }
+
+    it "creates specified number of associations" do
+      expect(user.posts.count).to eq(5)
+    end
+  end
+end
+
+# Polymorphic associations
+FactoryBot.define do
+  factory :comment do
+    body { "Comment" }
+
+    for_post  # Default trait
+
+    trait :for_post do
+      association :commentable, factory: :post
+    end
+
+    trait :for_article do
+      association :commentable, factory: :article
+    end
+
+    trait :for_video do
+      association :commentable, factory: :video
+    end
+  end
+end
+
+RSpec.describe "Polymorphic associations" do
+  describe "default polymorphic type" do
+    let(:comment) { create(:comment) }
+
+    it "uses default trait" do
+      expect(comment.commentable).to be_a(Post)
+    end
+  end
+
+  describe "alternate polymorphic types" do
+    let(:article_comment) { create(:comment, :for_article) }
+    let(:video_comment) { create(:comment, :for_video) }
+
+    it "uses trait-specified type" do
+      expect(article_comment.commentable).to be_a(Article)
+      expect(video_comment.commentable).to be_a(Video)
+    end
+  end
+end
+
+# Interconnected associations
+FactoryBot.define do
+  factory :account do
+    name { "Account" }
+    supplier { association(:supplier, account: instance) }
+  end
+
+  factory :supplier do
+    name { "Supplier" }
+    account { association(:account, supplier: instance) }
+  end
+end
+
+RSpec.describe "Interconnected associations" do
+  describe "bidirectional references" do
+    let(:account) { build(:account) }
+
+    it "creates circular reference" do
+      expect(account.supplier.account).to eq(account)
+    end
+  end
+end
+
+# Complex interconnected models
+FactoryBot.define do
+  factory :student do
+    name { "Student" }
+    school
+    profile { association(:profile, student: instance, school:) }
+  end
+
+  factory :profile do
+    bio { "Bio" }
+    school
+    student { association(:student, profile: instance, school:) }
+  end
+end
+
+RSpec.describe "Complex interconnected models" do
+  describe "shared associations" do
+    let(:student) { build(:student) }
+
+    it "shares the same school across related records" do
+      expect(student.profile.school).to eq(student.school)
+    end
+  end
+end
+
+# Overriding associations at call time
+RSpec.describe "Overriding associations" do
+  describe "passing existing record" do
+    let(:author) { create(:user, name: "Specific Author") }
+    let(:post) { create(:post, user: author) }
+
+    it "uses provided association" do
+      expect(post.user).to eq(author)
+      expect(post.user.name).to eq("Specific Author")
+    end
+  end
+
+  describe "nil association" do
+    let(:post) { build(:post, user: nil) }
+
+    it "allows nil" do
+      expect(post.user).to be_nil
+    end
+  end
+end

data/skills/rspec/examples/factory_bot/build_strategies.rb

@@ -0,0 +1,272 @@
+# FactoryBot: Build Strategies Examples
+# Source: factory_bot gem spec/acceptance/
+
+# Build strategies control how objects are constructed:
+# - build: in-memory, not persisted
+# - create: persisted to database
+# - build_stubbed: fake persisted (fastest)
+# - attributes_for: returns hash only
+
+# build - constructs without persisting
+RSpec.describe "build strategy" do
+  describe "basic usage" do
+    let(:user) { build(:user) }
+
+    it "creates a new record" do
+      expect(user).to be_new_record
+    end
+
+    it "does not persist to database" do
+      expect(user).not_to be_persisted
+    end
+
+    it "can validate" do
+      expect(user).to be_valid
+    end
+  end
+
+  describe "with attributes" do
+    let(:user) { build(:user, name: "Custom Name") }
+
+    it "applies attribute overrides" do
+      expect(user.name).to eq("Custom Name")
+    end
+  end
+
+  describe "with traits" do
+    let(:user) { build(:user, :admin) }
+
+    it "applies trait attributes" do
+      expect(user.admin).to be true
+    end
+  end
+
+  describe "with block" do
+    it "yields the built instance" do
+      build(:user, name: "John") do |user|
+        expect(user.name).to eq("John")
+        expect(user).to be_new_record
+      end
+    end
+  end
+
+  describe "associations" do
+    let(:post) { build(:post) }
+
+    it "builds associations (not persisted)" do
+      expect(post.author).to be_new_record
+    end
+  end
+end
+
+# create - constructs and persists
+RSpec.describe "create strategy" do
+  describe "basic usage" do
+    let(:user) { create(:user) }
+
+    it "is not a new record" do
+      expect(user).not_to be_new_record
+    end
+
+    it "is persisted" do
+      expect(user).to be_persisted
+    end
+
+    it "has a database ID" do
+      expect(user.id).to be_present
+    end
+  end
+
+  describe "associations" do
+    let(:post) { create(:post) }
+
+    it "creates associated records" do
+      expect(post.author).to be_persisted
+    end
+  end
+
+  describe "with block" do
+    it "yields the created instance" do
+      create(:user, name: "Jane") do |user|
+        expect(user.name).to eq("Jane")
+        expect(user).to be_persisted
+      end
+    end
+  end
+end
+
+# build_stubbed - fake persisted (fastest)
+RSpec.describe "build_stubbed strategy" do
+  describe "basic usage" do
+    let(:user) { build_stubbed(:user) }
+
+    it "appears persisted" do
+      expect(user).to be_persisted
+    end
+
+    it "is not a new record" do
+      expect(user).not_to be_new_record
+    end
+
+    it "has a sequential ID" do
+      expect(user.id).to be > 0
+    end
+
+    it "has timestamps set" do
+      expect(user.created_at).to be_present
+      expect(user.updated_at).to be_present
+    end
+
+    it "is not marked as changed" do
+      expect(user).not_to be_changed
+    end
+  end
+
+  describe "persistence methods raise" do
+    let(:user) { build_stubbed(:user) }
+
+    it "raises on save" do
+      expect { user.save }.to raise_error(RuntimeError)
+    end
+
+    it "raises on destroy" do
+      expect { user.destroy }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe "associations" do
+    let(:post) { build_stubbed(:post) }
+
+    it "stubs associations too" do
+      expect(post.author).to be_persisted
+      expect(post.author).not_to be_new_record
+    end
+  end
+end
+
+# attributes_for - returns hash only
+RSpec.describe "attributes_for strategy" do
+  describe "basic usage" do
+    subject(:attrs) { attributes_for(:user) }
+
+    it "returns a hash" do
+      expect(attrs).to be_a(Hash)
+    end
+
+    it "includes factory attributes" do
+      expect(attrs).to have_key(:name)
+      expect(attrs).to have_key(:email)
+    end
+
+    it "excludes associations" do
+      expect(attrs).not_to have_key(:posts)
+      expect(attrs).not_to have_key(:company_id)
+    end
+  end
+
+  describe "with overrides" do
+    subject(:attrs) { attributes_for(:user, name: "Custom") }
+
+    it "applies overrides" do
+      expect(attrs[:name]).to eq("Custom")
+    end
+  end
+
+  describe "with traits" do
+    subject(:attrs) { attributes_for(:user, :admin) }
+
+    it "applies trait attributes" do
+      expect(attrs[:admin]).to be true
+    end
+  end
+
+  describe "excludes transient attributes" do
+    # Given factory with transient { posts_count { 5 } }
+    subject(:attrs) { attributes_for(:user) }
+
+    it "does not include transient attributes" do
+      expect(attrs).not_to have_key(:posts_count)
+    end
+  end
+end
+
+# List methods
+RSpec.describe "list methods" do
+  describe "build_list" do
+    let(:users) { build_list(:user, 5) }
+
+    it "builds multiple records" do
+      expect(users.length).to eq(5)
+    end
+
+    it "builds without persisting" do
+      users.each do |user|
+        expect(user).to be_new_record
+      end
+    end
+  end
+
+  describe "create_list" do
+    let(:users) { create_list(:user, 3) }
+
+    it "creates multiple records" do
+      expect(users.length).to eq(3)
+    end
+
+    it "persists all records" do
+      users.each do |user|
+        expect(user).to be_persisted
+      end
+    end
+  end
+
+  describe "build_stubbed_list" do
+    let(:users) { build_stubbed_list(:user, 3) }
+
+    it "stubs multiple records" do
+      users.each do |user|
+        expect(user).to be_persisted
+        expect(user.id).to be > 0
+      end
+    end
+  end
+
+  describe "attributes_for_list" do
+    let(:attrs_list) { attributes_for_list(:user, 3) }
+
+    it "returns array of hashes" do
+      expect(attrs_list.length).to eq(3)
+      attrs_list.each { |attrs| expect(attrs).to be_a(Hash) }
+    end
+  end
+
+  describe "pair methods" do
+    let(:users) { create_pair(:user) }
+
+    it "creates exactly 2 records" do
+      expect(users.length).to eq(2)
+    end
+  end
+
+  describe "list with traits and overrides" do
+    let(:admins) { create_list(:user, 3, :admin, name: "Admin") }
+
+    it "applies traits to all" do
+      admins.each { |user| expect(user.admin).to be true }
+    end
+
+    it "applies overrides to all" do
+      admins.each { |user| expect(user.name).to eq("Admin") }
+    end
+  end
+
+  describe "list with block and index" do
+    it "yields each instance with index" do
+      users = build_list(:user, 3) do |user, index|
+        user.position = index + 1
+      end
+
+      expect(users.map(&:position)).to eq([1, 2, 3])
+    end
+  end
+end