Ruby on Rails 5.2 - ActiveRecord::FixtureSet

वर्ग ActiveRecord :: FixureSet




ruby

वर्ग ActiveRecord :: FixureSet

जनक:
Object

फिक्स्चर डेटा को व्यवस्थित करने का एक तरीका है जिसके खिलाफ आप परीक्षण करना चाहते हैं; संक्षेप में, नमूना डेटा।

उन्हें YAML फ़ाइलों में संग्रहीत किया जाता है, प्रति मॉडल एक फ़ाइल, जो ActiveSupport::TestCase.fixture_path=(path) द्वारा नियुक्त निर्देशिका में रखी गई है ActiveSupport::TestCase.fixture_path=(path) (यह स्वचालित रूप से रेल के लिए कॉन्फ़िगर किया गया है, इसलिए आप अपनी फ़ाइलों को <your-rails-app>/test/fixtures/ में डाल सकते हैं] <your-rails-app>/test/fixtures/ )। स्थिरता फ़ाइल .yml फ़ाइल एक्सटेंशन के साथ समाप्त होती है, उदाहरण के लिए: <your-rails-app>/test/fixtures/web_sites.yml )।

फ़िक्चर फ़ाइल का प्रारूप इस तरह दिखता है:

rubyonrails:
  id: 1
  name: Ruby on Rails
  url: http://www.rubyonrails.org

google:
  id: 2
  name: Google
  url: http://www.google.com

इस जुड़नार फ़ाइल में दो जुड़नार शामिल हैं। प्रत्येक YAML स्थिरता (यानी रिकॉर्ड) को एक नाम दिया जाता है और उसके बाद "कुंजी: मूल्य" प्रारूप में कुंजी / मूल्य जोड़े की एक इंडेंट सूची दी जाती है। आपके देखने के आनंद के लिए रिक्त पंक्ति द्वारा रिकॉर्ड अलग किए जाते हैं।

नोट: फिक्स्चर अनियंत्रित हैं। यदि आप जुड़नार का आदेश दिया चाहते हैं, तो omap YAML प्रकार का उपयोग करें। विनिर्देशन के लिए yaml.org/type/omap.html देखें। जब आपको एक ही तालिका में कुंजियों पर विदेशी कुंजी की कमी होती है, तो आपको फिक्स्ड ऑर्डर करने की आवश्यकता होगी। यह आमतौर पर पेड़ संरचनाओं के लिए आवश्यक है। उदाहरण:

--- !omap
- parent:
    id:         1
    parent_id:  NULL
    title:      Parent
- child:
    id:         2
    parent_id:  1
    title:      Child

परीक्षण मामलों में फिक्स्चर का उपयोग करना

चूंकि जुड़नार एक परीक्षण निर्माण है, इसलिए हम उन्हें अपनी इकाई और कार्यात्मक परीक्षणों में उपयोग करते हैं। जुड़नार का उपयोग करने के दो तरीके हैं, लेकिन पहले एक नमूना इकाई परीक्षण पर एक नज़र डालते हैं:

require 'test_helper'

class WebSiteTest < ActiveSupport::TestCase
  test "web_site_count" do
    assert_equal 2, WebSite.count
  end
end

डिफ़ॉल्ट रूप से, test_helper.rb आपके सभी जुड़नार को आपके परीक्षण डेटाबेस में लोड कर देगा, इसलिए यह परीक्षण सफल होगा।

परीक्षण वातावरण प्रत्येक परीक्षण से पहले डेटाबेस में सभी जुड़नार को स्वचालित रूप से लोड करेगा। लगातार डेटा सुनिश्चित करने के लिए, पर्यावरण लोड को चलाने से पहले जुड़नार को हटा देता है।

डेटाबेस में उपलब्ध होने के अलावा, फिक्स्चर के डेटा को एक विशेष गतिशील विधि का उपयोग करके भी एक्सेस किया जा सकता है, जिसका मॉडल के समान नाम है।

इस गतिशील विधि के लिए एक स्थिरता नाम में पासिंग इस नाम से मेल खाने वाले स्थिरता देता है:

test "find one" do
  assert_equal "Ruby on Rails", web_sites(:rubyonrails).name
end

कई फिक्स्चर नामों में पासिंग इन नामों से मेल खाते हुए सभी फिक्स्चर देता है:

test "find all by name" do
  assert_equal 2, web_sites(:rubyonrails, :google).length
end

बिना किसी तर्क के पास होने से सभी जुड़नार लौट जाते हैं:

test "find all" do
  assert_equal 2, web_sites.length
end

किसी भी स्थिरता नाम में मौजूद नहीं है जो StandardError को बढ़ाएगा:

test "find by name that does not exist" do
  assert_raise(StandardError) { web_sites(:reddit) }
end

वैकल्पिक रूप से, आप फ़िक्चर डेटा के ऑटो-इंस्टेंटेशन को सक्षम कर सकते हैं। उदाहरण के लिए, निम्नलिखित परीक्षण करें:

test "find_alt_method_1" do
  assert_equal "Ruby on Rails", @web_sites['rubyonrails']['name']
end

test "find_alt_method_2" do
  assert_equal "Ruby on Rails", @rubyonrails.name
end

अपने परीक्षण मामलों में डेटा को ठीक करने के लिए इन विधियों का उपयोग करने के लिए, आपको अपने ActiveSupport में निम्नलिखित में से एक को निर्दिष्ट करना होगा :: TestCase-व्युत्पन्न वर्ग:

  • पूरी तरह से तत्काल जुड़नार को सक्षम करने के लिए (वैकल्पिक तरीकों # 1 और # 2 ऊपर सक्षम करें)

    self.use_instantiated_fixtures = true
    
  • जुड़नार के लिए केवल हैश बनाएं, प्रत्येक उदाहरण को 'खोजें' न करें (वैकल्पिक विधि # 1 को ही सक्षम करें)

    self.use_instantiated_fixtures = :no_instances
    

इन वैकल्पिक तरीकों में से किसी एक का उपयोग करने से एक प्रदर्शन प्रभावित होता है, क्योंकि फिक्सड हैश और / या इंस्टेंस वैरिएबल बनाने के लिए डेटाबेस में फिक्स्ड डेटा को पूरी तरह से ट्रैवर्स किया जाना चाहिए। यह फिक्स्ड डेटा के बड़े सेट के लिए महंगा है।

साथ गतिशील जुड़नार

कभी-कभी आप फिक्स्चर की सामग्री के बारे में परवाह नहीं करते हैं जितना आप वॉल्यूम के बारे में परवाह करते हैं। इन मामलों में, आप लोड परीक्षण के लिए जुड़नार का एक गुच्छा बनाने के लिए अपने YAML जुड़नार के साथ ERB को मिला सकते हैं:

<% 1.upto(1000) do |i| %>
fix_<%= i %>:
  id: <%= i %>
  name: guy_<%= i %>
<% end %>

यह 1000 बहुत सरल जुड़नार बनाएगा।

<%= Date.today.strftime("%Y-%m-%d") %> का उपयोग करके, आप अपने फिक्स्चर में डायनामिक मानों को भी सम्मिलित कर सकते हैं जैसे <%= Date.today.strftime("%Y-%m-%d") %> । यह हालांकि कुछ सावधानी के साथ इस्तेमाल किया जाने वाला एक फीचर है। जुड़नार की बात यह है कि वे अनुमानित नमूना डेटा की स्थिर इकाइयाँ हैं। यदि आपको लगता है कि आपको गतिशील मूल्यों को इंजेक्ट करने की आवश्यकता है, तो शायद आपको यह पुन: जांचना चाहिए कि क्या आपका आवेदन ठीक से परीक्षण योग्य है। इसलिए, जुड़नार में गतिशील मूल्यों को एक कोड गंध माना जाता है।

अवांछित अंतर-परीक्षण निर्भरता के खिलाफ रोकने के लिए, एक जुड़नार में परिभाषित सहायक तरीके अन्य जुड़नार में उपलब्ध नहीं होंगे। एकाधिक जुड़नार द्वारा उपयोग किए जाने वाले तरीकों को एक मॉड्यूल में परिभाषित किया जाना चाहिए जो ::context_class में शामिल है।

  • test_helper.rb में एक सहायक विधि परिभाषित करें

    module FixtureFileHelpers
      def file_sha(path)
        Digest::SHA2.hexdigest(File.read(Rails.root.join('test/fixtures', path)))
      end
    end
    ActiveRecord::FixtureSet.context_class.include FixtureFileHelpers
    
  • एक स्थिरता में सहायक विधि का उपयोग करें

    photo:
      name: kitten.png
      sha: <%= file_sha 'files/kitten.png' %>

लेन-देन संबंधी परीक्षण

टेस्ट के मामले हर टेस्ट केस के लिए डिलीट + इंसर्ट करने के बजाय डेटाबेस में उनके बदलाव को अलग करने के लिए start + rollback का उपयोग कर सकते हैं।

class FooTest < ActiveSupport::TestCase
  self.use_transactional_tests = true

  test "godzilla" do
    assert_not_empty Foo.all
    Foo.destroy_all
    assert_empty Foo.all
  end

  test "godzilla aftermath" do
    assert_not_empty Foo.all
  end
end

यदि आप अपने परीक्षण डेटाबेस को सभी फ़िक्चर डेटा (शायद रेक कार्य में) के साथ लोड करते हैं और ट्रांसेक्शनल परीक्षणों का उपयोग करते हैं, तो आप अपने परीक्षण मामलों में सभी फिक्स्चर घोषणाओं को छोड़ सकते हैं क्योंकि सभी डेटा पहले से ही है और हर मामला अपने परिवर्तनों को वापस ले लेता है।

प्रीलोडेड डेटा के साथ तात्कालिक जुड़नार का उपयोग करने के लिए, self.pre_loaded_fixtures को सही पर सेट करें। यह जुड़नार के माध्यम से लोड की गई प्रत्येक तालिका के लिए use_instantiated_fixtures डेटा तक पहुंच प्रदान करेगा ( use_instantiated_fixtures के मूल्य के आधार पर)।

जब लेन-देन परीक्षणों का उपयोग नहीं करना है:

  1. आप परीक्षण कर रहे हैं कि क्या कोई लेन-देन सही तरीके से काम करता है नेस्टेड लेनदेन तब तक नहीं करते हैं जब तक कि सभी पैरेंट ट्रांजैक्शन कमिट नहीं हो जाते हैं, विशेष रूप से, फिक्स्चर ट्रांजेक्शन जो सेटअप में शुरू होता है और फाड़ में वापस आ जाता है। इस प्रकार, आप तब तक अपने लेन-देन के परिणामों को सत्यापित नहीं कर पाएंगे जब तक कि सक्रिय रिकॉर्ड नेस्टेड लेनदेन या सेवपॉइंट (प्रगति में) का समर्थन नहीं करता है।

  2. आपका डेटाबेस लेनदेन का समर्थन नहीं करता है। हर सक्रिय रिकॉर्ड डेटाबेस MySQL MyISAM को छोड़कर लेनदेन का समर्थन करता है। इसके बजाय InnoDB, MaxDB या NDB का उपयोग करें।

उन्नत फिक्स्चर

फिक्स्चर जो एक आईडी निर्दिष्ट नहीं करते हैं उन्हें कुछ अतिरिक्त सुविधाएं मिलती हैं:

  • स्थिर, स्वचालित आईडी

  • संघों के लिए लेबल संदर्भ (has_to, has_one, has_many)

  • इनलाइन सूचियों के रूप में HABTM संघों

आईडी निर्दिष्ट होने पर भी कुछ और उन्नत सुविधाएँ उपलब्ध हैं:

  • स्वतःभरण टाइमस्टैम्प कॉलम

  • स्थिरता लेबल प्रक्षेप

  • YAML चूक के लिए समर्थन

स्थिर, स्वचालित आईडी

यहाँ, एक बंदर स्थिरता है:

george:
  id: 1
  name: George the Monkey

reginald:
  id: 2
  name: Reginald the Pirate

इनमें से प्रत्येक जुड़नार में दो विशिष्ट पहचानकर्ता होते हैं: एक डेटाबेस के लिए और दूसरा मानवों के लिए। हम इसके बजाय प्राथमिक कुंजी क्यों नहीं बनाते हैं? प्रत्येक फिक्सेटर के लेबल को हिट करने से एक सुसंगत आईडी प्राप्त होती है:

george: # generated id: 503576764
  name: George the Monkey

reginald: # generated id: 324201669
  name: Reginald the Pirate

एक्टिव रिकॉर्ड फ़िक्चर के मॉडल क्लास को देखता है, सही प्राथमिक कुंजी को दिखाता है और डेटाबेस में फ़िक्चर डालने से पहले इसे सही बनाता है।

किसी दिए गए लेबल के लिए जनरेट आईडी स्थिर है, इसलिए जब तक हम लेबल को जानते हैं, तब तक हम कुछ भी लोड किए बिना किसी भी स्थिरता की आईडी खोज सकते हैं।

संघों के लिए लेबल संदर्भ (has_to, has_one, has_many)

जुड़नार में विदेशी कुंजी निर्दिष्ट करना बहुत नाजुक हो सकता है, पढ़ने में मुश्किल का उल्लेख नहीं करना। चूंकि एक्टिव रिकॉर्ड इसके लेबल से किसी भी स्थिरता का आईडी पता लगा सकता है, आप आईडी के बजाय एफके बाय लेबल निर्दिष्ट कर सकते हैं।

का है

चलो कुछ और बंदरों और समुद्री डाकू को तोड़ते हैं।

### in pirates.yml

reginald:
  id: 1
  name: Reginald the Pirate
  monkey_id: 1

### in monkeys.yml

george:
  id: 1
  name: George the Monkey
  pirate_id: 1

कुछ और बंदर और समुद्री डाकू जोड़ें और इसे कई फाइलों में तोड़ दें, और जो चल रहा है उसका ट्रैक रखना बहुत कठिन हो जाता है। आइडी के बजाय लेबल का उपयोग करें:

### in pirates.yml

reginald:
  name: Reginald the Pirate
  monkey: george

### in monkeys.yml

george:
  name: George the Monkey
  pirate: reginald

पाउ! सब स्पष्ट कर दिया है। सक्रिय रिकॉर्ड स्थिरता के मॉडल वर्ग को दर्शाता है, सभी belongs_to संघों को पाता है, और आपको एफके ( monkey_id: 1 ) के लिए लक्ष्य आईडी के बजाय एसोसिएशन (बंदर: जॉर्ज) के लिए एक लक्ष्य लेबल निर्दिष्ट करने की अनुमति देता है।

बहुरूपी अंतर्गत_तो

पॉलीमॉर्फिक संबंधों का समर्थन करना थोड़ा अधिक जटिल है, क्योंकि सक्रिय रिकॉर्ड को यह जानना आवश्यक है कि आपका संघ किस प्रकार की ओर इशारा कर रहा है। कुछ इस तरह परिचित होना चाहिए:

### in fruit.rb

belongs_to :eater, polymorphic: true

### in fruits.yml

apple:
  id: 1
  name: apple
  eater_id: 1
  eater_type: Monkey

क्या हम बेहतर कर सकते हैं? बिलकुल!

apple:
  eater: george (Monkey)

बस बहुरूपिया लक्ष्य प्रकार प्रदान करें और सक्रिय रिकॉर्ड बाकी की देखभाल करेगा।

has_and_belongs_to_many

हमारे बंदर को कुछ फल देने का Time

### in monkeys.yml

george:
  id: 1
  name: George the Monkey

### in fruits.yml

apple:
  id: 1
  name: apple

orange:
  id: 2
  name: orange

grape:
  id: 3
  name: grape

### in fruits_monkeys.yml

apple_george:
  fruit_id: 1
  monkey_id: 1

orange_george:
  fruit_id: 2
  monkey_id: 1

grape_george:
  fruit_id: 3
  monkey_id: 1

चलिए HABTM स्थिरता को दूर करते हैं।

### in monkeys.yml

george:
  id: 1
  name: George the Monkey
  fruits: apple, orange, grape

### in fruits.yml

apple:
  name: apple

orange:
  name: orange

grape:
  name: grape

जैप! कोई और अधिक fruit_monkeys.yml फ़ाइल। हमने जॉर्ज की स्थिरता पर फलों की सूची निर्दिष्ट की है, लेकिन हम प्रत्येक फल पर बंदरों की सूची को आसानी से निर्दिष्ट कर सकते हैं। के साथ के रूप में belongs_to , सक्रिय रिकॉर्ड स्थिरता के मॉडल वर्ग पर प्रतिबिंबित करता है और has_and_belongs_to_many पता चलता है।

स्वतःभरण Timestamp कॉलम

यदि आपका टेबल / मॉडल सक्रिय रिकॉर्ड के किसी भी मानक टाइमस्टैम्प कॉलम ( created_at , created_on , updated_at , updated_on ) को updated_on , तो वे स्वचालित रूप से updated_on सेट हो जाएंगे।

यदि आपने विशिष्ट मान सेट किए हैं, तो वे अकेले रह जाएंगे।

स्थिरता लेबल प्रक्षेप

वर्तमान स्थिरता का लेबल हमेशा स्तंभ मान के रूप में उपलब्ध होता है:

geeksomnia:
  name: Geeksomnia's Account
  subdomain: $LABEL
  email: [email protected]

इसके अलावा, कभी-कभी (जैसे कि पुराने जुड़ने वाले टेबल जुड़नार को पोर्ट करते समय) आपको दिए गए लेबल के लिए पहचानकर्ता की पकड़ पाने में सक्षम होना चाहिए। बचाव के लिए ERB :

george_reginald:
  monkey_id: <%= ActiveRecord::FixtureSet.identify(:reginald) %>
  pirate_id: <%= ActiveRecord::FixtureSet.identify(:george) %>

YAML चूक के लिए समर्थन

आप अपने फिक्स्चर YAML फ़ाइल में डिफॉल्ट को सेट और पुन: उपयोग कर सकते हैं। यह वही तकनीक है जिसका उपयोग database.yml में किया जाता है। चूक को निर्दिष्ट करने के लिए फाइल।

DEFAULTS: &DEFAULTS
  created_on: <%= 3.weeks.ago.to_s(:db) %>

first:
  name: Smurf
  <<: *DEFAULTS

second:
  name: Fraggle
  <<: *DEFAULTS

"DEFAULTS" नामक किसी भी स्थिरता को सुरक्षित रूप से अनदेखा किया जाता है।

फ़िक्चर मॉडल वर्ग कॉन्फ़िगर करें

यह यमलोक फ़ाइल में सीधे फिचर के मॉडल वर्ग को सेट करना संभव है। यह तब सहायक होता है जब जुड़नार को बाहर के परीक्षणों में लोड किया जाता है और set_fixture_class उपलब्ध नहीं होता है (उदाहरण के लिए rails db:fixtures:load चलाते समय rails db:fixtures:load )।

_fixture:
  model_class: User
david:
  name: David

किसी भी जुड़नार "_fixचर" लेबल सुरक्षित रूप से नजरअंदाज कर रहे हैं।

स्थिरांक

MAX_ID

गुण

विन्यास [R]
जुड़नार [आर]
model_class [R]
नाम [R]
table_name [R]

पब्लिक क्लास के तरीके

cache_fixtures (कनेक्शन, जुड़नार_मैप ) दिखाएँ स्रोत
# File activerecord/lib/active_record/fixtures.rb, line 475
def self.cache_fixtures(connection, fixtures_map)
  cache_for_connection(connection).update(fixtures_map)
end
cache_for_connection (कनेक्शन) स्रोत दिखाएं
# File activerecord/lib/active_record/fixtures.rb, line 459
def self.cache_for_connection(connection)
  @@all_cached_fixtures[connection]
end
कैश्ड_फिशियन्स (कनेक्शन, कीज़_टो_फेट = नील) स्रोत दिखाएँ
# File activerecord/lib/active_record/fixtures.rb, line 467
def self.cached_fixtures(connection, keys_to_fetch = nil)
  if keys_to_fetch
    cache_for_connection(connection).values_at(*keys_to_fetch)
  else
    cache_for_connection(connection).values
  end
end
संदर्भ_क्लास () स्रोत दिखाएं
# File activerecord/lib/active_record/fixtures.rb, line 590
def self.context_class
  @context_class ||= Class.new
end

ईआरबी फिक्स्चर द्वारा उपयोग किए जाने वाले मूल्यांकन संदर्भों के लिए सुपरक्लास।

create_fixtures (जुड़नार_निर्देशिका, fix_set_names, class_names = {}, config = ActiveRecord :: Base) {|: कनेक्शन | ...} स्रोत दिखाएं
# File activerecord/lib/active_record/fixtures.rb, line 531
def self.create_fixtures(fixtures_directory, fixture_set_names, class_names = {}, config = ActiveRecord::Base)
  fixture_set_names = Array(fixture_set_names).map(&:to_s)
  class_names = ClassCache.new class_names, config

  # FIXME: Apparently JK uses this.
  connection = block_given? ? yield : ActiveRecord::Base.connection

  files_to_read = fixture_set_names.reject { |fs_name|
    fixture_is_cached?(connection, fs_name)
  }

  unless files_to_read.empty?
    fixtures_map = {}

    fixture_sets = files_to_read.map do |fs_name|
      klass = class_names[fs_name]
      conn = klass ? klass.connection : connection
      fixtures_map[fs_name] = new( # ActiveRecord::FixtureSet.new
        conn,
        fs_name,
        klass,
        ::File.join(fixtures_directory, fs_name))
    end

    update_all_loaded_fixtures fixtures_map
    fixture_sets_by_connection = fixture_sets.group_by { |fs| fs.model_class ? fs.model_class.connection : connection }

    fixture_sets_by_connection.each do |conn, set|
      table_rows_for_connection = Hash.new { |h, k| h[k] = [] }

      set.each do |fs|
        fs.table_rows.each do |table, rows|
          table_rows_for_connection[table].unshift(*rows)
        end
      end
      conn.insert_fixtures_set(table_rows_for_connection, table_rows_for_connection.keys)

      # Cap primary key sequences to max(pk).
      if conn.respond_to?(:reset_pk_sequence!)
        set.each { |fs| conn.reset_pk_sequence!(fs.table_name) }
      end
    end

    cache_fixtures(connection, fixtures_map)
  end
  cached_fixtures(connection, fixture_set_names)
end
fixture_is_cached? (कनेक्शन, table_name) स्रोत दिखाएं
# File activerecord/lib/active_record/fixtures.rb, line 463
def self.fixture_is_cached?(connection, table_name)
  cache_for_connection(connection)[table_name]
end
पहचान (लेबल, column_type =: पूर्णांक) स्रोत दिखाएं
# File activerecord/lib/active_record/fixtures.rb, line 581
def self.identify(label, column_type = :integer)
  if column_type == :uuid
    Digest::UUID.uuid_v5(Digest::UUID::OID_NAMESPACE, label.to_s)
  else
    Zlib.crc32(label.to_s) % MAX_ID
  end
end

label लिए एक सुसंगत, प्लेटफ़ॉर्म-स्वतंत्र पहचानकर्ता देता है। Integer पहचानकर्ता 2 ^ 30 से कम के मान हैं। UUIDs RFC 4122 संस्करण 5 SHA-1 हैश हैं।

Instantiate_all_loaded_fixtures (ऑब्जेक्ट, load_instances = true) स्रोत दिखाएं
# File activerecord/lib/active_record/fixtures.rb, line 491
def self.instantiate_all_loaded_fixtures(object, load_instances = true)
  all_loaded_fixtures.each_value do |fixture_set|
    instantiate_fixtures(object, fixture_set, load_instances)
  end
end
झटपट_ उपसर्ग (ऑब्जेक्ट, फ़िक्चर_सेट, लोड_स्टेंस = सत्य) स्रोत दिखाएं
# File activerecord/lib/active_record/fixtures.rb, line 479
def self.instantiate_fixtures(object, fixture_set, load_instances = true)
  if load_instances
    fixture_set.each do |fixture_name, fixture|
      begin
        object.instance_variable_set "@#{fixture_name}", fixture.find
      rescue FixtureClassNotFound
        nil
      end
    end
  end
end
नया (कनेक्शन, नाम, class_name, path, config = ActiveRecord :: Base) स्रोत दिखाएं
# File activerecord/lib/active_record/fixtures.rb, line 600
def initialize(connection, name, class_name, path, config = ActiveRecord::Base)
  @name     = name
  @path     = path
  @config   = config

  self.model_class = class_name

  @fixtures = read_fixture_files(path)

  @connection = connection

  @table_name = (model_class.respond_to?(:table_name) ?
                  model_class.table_name :
                  self.class.default_fixture_table_name(name, config))
end
# File activerecord/lib/active_record/fixtures.rb, line 455
def self.reset_cache
  @@all_cached_fixtures.clear
end

सार्वजनिक प्रवृत्ति के तरीके

# File activerecord/lib/active_record/fixtures.rb, line 616
def [](x)
  fixtures[x]
end
# File activerecord/lib/active_record/fixtures.rb, line 620
def []=(k, v)
  fixtures[k] = v
end
प्रत्येक (और ब्लॉक) दिखाएँ स्रोत
# File activerecord/lib/active_record/fixtures.rb, line 624
def each(&block)
  fixtures.each(&block)
end
# File activerecord/lib/active_record/fixtures.rb, line 628
def size
  fixtures.size
end
# File activerecord/lib/active_record/fixtures.rb, line 634
def table_rows
  now = config.default_timezone == :utc ? Time.now.utc : Time.now

  # allow a standard key to be used for doing defaults in YAML
  fixtures.delete("DEFAULTS")

  # track any join tables we need to insert later
  rows = Hash.new { |h, table| h[table] = [] }

  rows[table_name] = fixtures.map do |label, fixture|
    row = fixture.to_hash

    if model_class
      # fill in timestamp columns if they aren't specified and the model is set to record_timestamps
      if model_class.record_timestamps
        timestamp_column_names.each do |c_name|
          row[c_name] = now unless row.key?(c_name)
        end
      end

      # interpolate the fixture label
      row.each do |key, value|
        row[key] = value.gsub("$LABEL", label.to_s) if value.is_a?(String)
      end

      # generate a primary key if necessary
      if has_primary_key_column? && !row.include?(primary_key_name)
        row[primary_key_name] = ActiveRecord::FixtureSet.identify(label, primary_key_type)
      end

      # Resolve enums
      model_class.defined_enums.each do |name, values|
        if row.include?(name)
          row[name] = values.fetch(row[name], row[name])
        end
      end

      # If STI is used, find the correct subclass for association reflection
      reflection_class =
        if row.include?(inheritance_column_name)
          row[inheritance_column_name].constantize rescue model_class
        else
          model_class
        end

      reflection_class._reflections.each_value do |association|
        case association.macro
        when :belongs_to
          # Do not replace association name with association foreign key if they are named the same
          fk_name = (association.options[:foreign_key] || "#{association.name}_id").to_s

          if association.name.to_s != fk_name && value = row.delete(association.name.to_s)
            if association.polymorphic? && value.sub!(/\s*\(([^\)]*)\)\s*$/, "")
              # support polymorphic belongs_to as "label (Type)"
              row[association.foreign_type] = $1
            end

            fk_type = reflection_class.type_for_attribute(fk_name).type
            row[fk_name] = ActiveRecord::FixtureSet.identify(value, fk_type)
          end
        when :has_many
          if association.options[:through]
            add_join_records(rows, row, HasManyThroughProxy.new(association))
          end
        end
      end
    end

    row
  end
  rows
end

सम्मिलित की जाने वाली पंक्तियों का एक हैश लौटाता है। कुंजी तालिका है, मान उस तालिका में सम्मिलित करने के लिए पंक्तियों की एक सूची है।