mr 0.35.2

data/test/unit/factory/record_stack_tests.rb

@@ -0,0 +1,549 @@
+require 'assert'
+require 'mr/factory/record_stack'
+
+require 'mr/factory/model_factory'
+require 'mr/factory/record_factory'
+require 'mr/fake_record'
+require 'mr/model'
+
+class MR::Factory::RecordStack
+
+  class UnitTests < Assert::Context
+    desc "MR::Factory::RecordStack"
+    setup do
+      @factory_config_class = if Factory.boolean
+        MR::Factory::RecordFactory::Config
+      else
+        MR::Factory::ModelFactory::Config
+      end
+
+      @stack_class = MR::Factory::RecordStack
+    end
+    subject{ @stack_class }
+
+    should have_imeths :for_record
+
+    should "know how to build itself from a record" do
+      record_class   = TestFakeRecord
+      record         = record_class.new
+      factory_config = @factory_config_class.new(record_class)
+
+      record_data = RecordData.new(record)
+      Assert.stub(RecordData, :new).with(record){ record_data }
+
+      stack_built_with = nil
+      Assert.stub(subject, :new){ |*args| stack_built_with = args }
+
+      subject.for_record(record, factory_config)
+
+      assert_equal [record_data, factory_config], stack_built_with
+    end
+
+  end
+
+  class InitSetupTests < UnitTests
+    desc "when init"
+    subject{ @record_stack }
+
+  end
+
+  class InitTests < InitSetupTests
+    setup do
+      @record_class   = FakeFourRecord
+      @record         = @record_class.new(:fake_poly_type => FakeThreeRecord.to_s)
+      @factory_config = @factory_config_class.new(@record_class)
+      @record_data    = RecordData.new(@record)
+
+      # record stacks are recursive, only stub association datas that are built
+      # for our record
+      @get_record_data_called_with = []
+      @association_record_datas    = []
+      @record_data.association_datas.each do |association_data|
+        Assert.stub(association_data, :get_record_data) do |*args|
+          @get_record_data_called_with << args
+          record = Assert.stub_send(association_data, :get_record_data, *args)
+          @association_record_datas << record
+          record
+        end
+      end
+
+      @record_stack = @stack_class.new(@record_data, @factory_config)
+    end
+
+    should have_readers :record_data, :factory_config, :record_lookup
+    should have_readers :record_stacks
+    should have_imeths :record
+    should have_imeths :create, :destroy
+    should have_imeths :create_dependencies, :create_deps
+    should have_imeths :destroy_dependencies, :destroy_deps
+
+    should "know its record data, factory config, record lookup and its record" do
+      assert_equal @record_data,        subject.record_data
+      assert_equal @factory_config,     subject.factory_config
+      assert_equal @record_data.record, subject.record
+
+      assert_instance_of Hash, subject.record_lookup
+    end
+
+    should "know its record stacks" do
+      association_datas = @record_data.association_datas.select do |data|
+        data.required?(@factory_config)
+      end
+
+      assert_equal association_datas.size, subject.record_lookup.size
+      assert_equal association_datas.size, subject.record_stacks.size
+
+      subject.record_stacks.each_with_index do |record_stack, n|
+        association_data            = association_datas[n]
+        associated_record_data      = @association_record_datas[n]
+        get_record_data_called_with = @get_record_data_called_with[n]
+        assoc_factory_config        = @factory_config.factory_config_for(
+          association_data.name,
+          associated_record_data.record_class
+        )
+
+        # get the associated record data
+        exp = [@factory_config, subject.record_lookup]
+        assert_equal exp, get_record_data_called_with
+
+        # set the association on the record
+        exp = associated_record_data.record
+        assert_equal exp, @record.send(association_data.name)
+
+        # update the record lookup
+        record_data = subject.record_lookup[associated_record_data.record.class]
+        assert_same associated_record_data, record_data
+
+        # build a record stack
+        assert_instance_of @stack_class, record_stack
+        assert_equal associated_record_data, record_stack.record_data
+        assert_equal assoc_factory_config,   record_stack.factory_config
+        assert_equal subject.record_lookup,  record_stack.record_lookup
+      end
+    end
+
+    should "know how to create the full stack" do
+      call_order = 0
+
+      create_record_called_at = nil
+      Assert.stub(subject.record_data, :create_record) do
+        create_record_called_at = call_order += 1
+      end
+      create_deps_called_at = nil
+      Assert.stub(subject, :create_dependencies) do
+        create_deps_called_at = call_order += 1
+      end
+
+      assert_true subject.create
+      assert_equal 1, create_deps_called_at
+      assert_equal 2, create_record_called_at
+    end
+
+    should "know how to destroy the full stack" do
+      call_order = 0
+
+      destroy_record_called_at = nil
+      Assert.stub(subject.record_data, :destroy_record) do
+        destroy_record_called_at = call_order += 1
+      end
+      destroy_deps_called_at = nil
+      Assert.stub(subject, :destroy_dependencies) do
+        destroy_deps_called_at = call_order += 1
+      end
+
+      assert_true subject.destroy
+      assert_equal 1, destroy_record_called_at
+      assert_equal 2, destroy_deps_called_at
+    end
+
+    should "know how to create its dependencies" do
+      call_order = 0
+
+      refresh_associations_called_at = nil
+      Assert.stub(subject.record_data, :refresh_record_associations) do
+        refresh_associations_called_at = call_order += 1
+      end
+      record_stacks_create_called_at = nil
+      created_record_stacks          = []
+      subject.record_stacks.each do |record_stack|
+        Assert.stub(record_stack, :create) do
+          record_stacks_create_called_at ||= call_order += 1
+          created_record_stacks << record_stack
+        end
+      end
+
+      assert_true subject.create
+      assert_equal 1, record_stacks_create_called_at
+      assert_equal 2, refresh_associations_called_at
+      assert_equal subject.record_stacks, created_record_stacks
+    end
+
+    should "know how to destroy its dependencies" do
+      destroyed_record_stacks = []
+      subject.record_stacks.each do |record_stack|
+        Assert.stub(record_stack, :destroy) do
+          destroyed_record_stacks << record_stack
+        end
+      end
+
+      assert_true subject.destroy
+      assert_equal subject.record_stacks, destroyed_record_stacks
+    end
+
+    class FakeOneRecord;   include MR::FakeRecord; end
+    class FakeTwoRecord;   include MR::FakeRecord; end
+    class FakeThreeRecord; include MR::FakeRecord; end
+
+    class FakeFourRecord
+      include MR::FakeRecord
+
+      attribute :fake_poly_type, :string,  :null => false
+      attribute :fake_poly_id,   :integer, :null => false
+      attribute :fake_one_id,    :integer, :null => false
+      attribute :fake_two_id,    :integer, :null => false
+
+      attribute :not_required_poly_type, :string,  :null => true
+      attribute :not_required_poly_id,   :integer, :null => true
+      attribute :not_required_id,        :integer, :null => true
+
+      belongs_to :fake_poly, :polymorphic => true
+      belongs_to :fake_one,  :class_name  => FakeOneRecord.to_s
+      belongs_to :fake_two,  :class_name  => FakeTwoRecord.to_s
+
+      belongs_to :not_required_poly, :polymorphic => true
+      belongs_to :not_required,      :class_name  => FakeOneRecord.to_s
+    end
+
+    class FakeOneModel
+      include MR::Model
+      record_class FakeOneRecord
+    end
+
+    class FakeTwoModel
+      include MR::Model
+      record_class FakeTwoRecord
+    end
+
+    class FakeThreeModel
+      include MR::Model
+      record_class FakeThreeRecord
+    end
+
+    class FakeFourModel
+      include MR::Model
+      record_class FakeFourRecord
+
+      field_accessor :fake_poly_type, :fake_poly_id, :fake_one_id, :fake_two_id
+
+      polymorphic_belongs_to :fake_poly
+      belongs_to :fake_one
+      belongs_to :fake_two
+    end
+
+  end
+
+  class InitWithDeeplyNestedPresetsTests < InitSetupTests
+    desc "with deeply nested preset associations"
+    setup do
+      @record_class   = FakeThreeRecord
+      @record         = @record_class.new
+      @factory_config = @factory_config_class.new(@record_class)
+
+      @fake_one_record = FakeOneRecord.new
+
+      @fake_two_record          = FakeTwoRecord.new
+      @fake_two_record.fake_one = @fake_one_record
+
+      @record.fake_two = @fake_two_record
+
+      @record_data  = RecordData.new(@record)
+      @record_stack = @stack_class.new(@record_data, @factory_config)
+    end
+
+    should "use the preset record for all matching associations" do
+      assert_equal @fake_one_record, @record.fake_one
+    end
+
+    class FakeOneRecord; include MR::FakeRecord; end
+
+    class FakeTwoRecord
+      include MR::FakeRecord
+
+      attribute :fake_one_id, :integer, :null => false
+
+      belongs_to :fake_one, :class_name => FakeOneRecord.to_s
+    end
+
+    class FakeThreeRecord
+      include MR::FakeRecord
+
+      attribute :fake_one_id, :integer, :null => false
+      attribute :fake_two_id, :integer, :null => false
+
+      belongs_to :fake_one, :class_name => FakeOneRecord.to_s
+      belongs_to :fake_two, :class_name => FakeTwoRecord.to_s
+    end
+
+  end
+
+  class RecordDataAndAssociationDataSetupTests < UnitTests
+    setup do
+      @record_class   = TestFakeRecord
+      @record         = @record_class.new
+      @factory_config = @factory_config_class.new(@record_class)
+    end
+
+  end
+
+  class RecordDataTests < RecordDataAndAssociationDataSetupTests
+    desc "Record"
+    setup do
+      @record_data_class = RecordData
+      @record_data       = @record_data_class.new(@record)
+    end
+    subject{ @record_data }
+
+    should have_readers :record, :association_datas
+    should have_imeths :record_class, :create_record, :destroy_record
+    should have_imeths :set_association, :refresh_record_associations
+
+    should "know its record and record class" do
+      assert_equal @record,       subject.record
+      assert_equal @record.class, subject.record_class
+    end
+
+    should "build association datas from its records associations" do
+      exp_association_names = [:another, :not_required, :other]
+
+      assert_equal exp_association_names.size, subject.association_datas.size
+      subject.association_datas.each_with_index do |association_data, n|
+        exp_association_name = exp_association_names[n]
+
+        assert_instance_of AssociationData, association_data
+        assert_equal exp_association_name, association_data.name
+      end
+    end
+
+    should "save a record using `create_record` if it's a new record" do
+      assert_true @record.new_record?
+      subject.create_record
+      assert_false @record.new_record?
+
+      Assert.stub(@record, :save!){ raise "shouldn't be called" }
+      assert_nothing_raised{ subject.create_record }
+    end
+
+    should "reset a fake records save called flag using `create_record`" do
+      assert_false @record.save_called
+      subject.create_record
+      assert_false @record.save_called
+    end
+
+    should "set an association from a record data using `set_association`" do
+      another_record      = AnotherFakeRecord.new.tap(&:save!)
+      another_record_data = @record_data_class.new(another_record)
+
+      subject.set_association(:another, another_record_data)
+      assert_equal another_record, @record.another
+    end
+
+    should "reset associations to properly set foreign keys " \
+           "using `refresh_associations`" do
+      another_record  = AnotherFakeRecord.new
+      @record.another = another_record
+      another_record.save!
+
+      assert_nil @record.another_id
+      subject.refresh_record_associations
+      assert_equal another_record.id, @record.another_id
+    end
+
+  end
+
+  class AssociationDataTests < UnitTests
+    desc "AssociationData"
+    setup do
+      @record_class = FakeTwoRecord
+      @record       = @record_class.new
+      @association  = @record.association(:fake_one)
+
+      @associated_record_class = FakeOneRecord
+      @factory_config          = @factory_config_class.new(@record_class)
+      @record_lookup           = {}
+
+      @association_data_class = AssociationData
+      @association_data       = @association_data_class.new(@association)
+    end
+    subject{ @association_data }
+
+    should have_readers :association, :preset_record_data
+    should have_imeths :name, :record_class, :preset?, :required?
+    should have_imeths :get_record_data
+
+    should "know its attributes" do
+      assert_equal @association,                 subject.association
+      assert_equal @association.reflection.name, subject.name
+      assert_equal @association.klass,           subject.record_class
+    end
+
+    should "know if it's preset" do
+      assert_false subject.preset?
+
+      preset_record = @associated_record_class.new
+      @record.send("#{subject.name}=", preset_record)
+
+      association_data = @association_data_class.new(@association)
+      assert_true association_data.preset?
+    end
+
+    should "know if it's required" do
+      assert_true subject.required?(@factory_config)
+
+      association      = @record.association(:fake_poly)
+      association_data = @association_data_class.new(association)
+      assert_true association_data.required?(@factory_config)
+
+      association      = @record.association(:required_key_poly)
+      association_data = @association_data_class.new(association)
+      assert_true association_data.required?(@factory_config)
+
+      association      = @record.association(:required_type_poly)
+      association_data = @association_data_class.new(association)
+      assert_true association_data.required?(@factory_config)
+
+      association      = @record.association(:not_required)
+      association_data = @association_data_class.new(association)
+      assert_false association_data.required?(@factory_config)
+
+      @factory_config.force_in_stack_association_names << association_data.name
+      assert_true association_data.required?(@factory_config)
+
+      association      = @record.association(:not_required_poly)
+      association_data = @association_data_class.new(association)
+      assert_false association_data.required?(@factory_config)
+
+      @factory_config.force_in_stack_association_names << association_data.name
+      assert_true association_data.required?(@factory_config)
+    end
+
+    should "return its preset when getting record data for a preset association" do
+      preset_record = @associated_record_class.new
+      @association.owner.send("#{@association.reflection.name}=", preset_record)
+
+      association_data = @association_data_class.new(@association)
+      assert_true association_data.preset?
+      exp = association_data.preset_record_data
+      assert_same exp, association_data.get_record_data(@factory_config, @record_lookup)
+    end
+
+    should "return a matching lookup value when not preset and getting record data" do
+      lookup_record = @associated_record_class.new
+      @record_lookup[lookup_record.class] = RecordData.new(lookup_record)
+
+      association_data = @association_data_class.new(@association)
+      assert_false association_data.preset?
+      exp = @record_lookup[lookup_record.class]
+      assert_same exp, association_data.get_record_data(@factory_config, @record_lookup)
+    end
+
+    should "return a matching lookup value for poly assoc when getting record data" do
+      association = @record.association(:fake_poly)
+
+      lookup_record = @associated_record_class.new
+      @record_lookup[lookup_record.class] = RecordData.new(lookup_record)
+
+      record_classes = [@associated_record_class, @record_class]
+      Assert.stub(@factory_config, :record_classes_for).with(
+        association.reflection.name
+      ){ record_classes }
+      Assert.stub(record_classes, :sample){ @associated_record_class }
+
+      association_data = @association_data_class.new(association)
+      assert_false association_data.preset?
+      assert_nil association_data.record_class
+      exp = @record_lookup[lookup_record.class]
+      assert_same exp, association_data.get_record_data(@factory_config, @record_lookup)
+    end
+
+    should "build a record when getting record data with no lookup or preset" do
+      associated_record = @associated_record_class.new
+      Assert.stub(@factory_config, :build_associated_record).with(
+        @association.reflection.name,
+        @association.klass
+      ){ associated_record }
+
+      association_data = @association_data_class.new(@association)
+      assert_false association_data.preset?
+      record_data = association_data.get_record_data(@factory_config, @record_lookup)
+      assert_instance_of RecordData, record_data
+      assert_same associated_record, record_data.record
+    end
+
+    should "be sortable" do
+      association_datas = [:fake_one, :fake_poly].shuffle.map do |association_name|
+        @association_data_class.new(@record.association(association_name))
+      end.sort
+
+      assert_equal [:fake_one, :fake_poly], association_datas.map(&:name)
+    end
+
+    class FakeOneRecord; include MR::FakeRecord; end
+
+    class FakeTwoRecord
+      include MR::FakeRecord
+
+      attribute :fake_poly_type, :string,  :null => false
+      attribute :fake_poly_id,   :integer, :null => false
+      attribute :fake_one_id,    :integer, :null => false
+
+      attribute :required_type_poly_type, :string,  :null => false
+      attribute :required_type_poly_id,   :integer, :null => true
+
+      attribute :required_key_poly_type, :string,  :null => true
+      attribute :required_key_poly_id,   :integer, :null => false
+
+      attribute :not_required_poly_type, :string,  :null => true
+      attribute :not_required_poly_id,   :integer, :null => true
+      attribute :not_required_id,        :integer, :null => true
+
+      belongs_to :fake_poly, :polymorphic => true
+      belongs_to :fake_one,  :class_name  => FakeOneRecord.to_s
+
+      belongs_to :required_type_poly, :polymorphic => true
+      belongs_to :required_key_poly,  :polymorphic => true
+
+      belongs_to :not_required_poly, :polymorphic => true
+      belongs_to :not_required,      :class_name  => FakeOneRecord.to_s
+    end
+
+  end
+
+  class TestFakeRecord
+    include MR::FakeRecord
+
+    attribute :id,              :primary_key
+    attribute :other_id,        :integer,     :null => false
+    attribute :another_id,      :integer,     :null => false
+    attribute :not_required_id, :integer,     :null => true
+
+    belongs_to :other,        :class_name => 'MR::Factory::RecordStack::OtherFakeRecord'
+    belongs_to :another,      :class_name => 'MR::Factory::RecordStack::AnotherFakeRecord'
+    belongs_to :not_required, :class_name => 'MR::Factory::RecordStack::OtherFakeRecord'
+  end
+
+  class OtherFakeRecord
+    include MR::FakeRecord
+
+    attribute :id, :primary_key
+  end
+
+  class AnotherFakeRecord
+    include MR::FakeRecord
+
+    attribute :id,       :primary_key
+    attribute :other_id, :integer,     :null => false
+
+    belongs_to :other, :class_name => 'MR::Factory::RecordStack::OtherFakeRecord'
+  end
+
+end