mr 0.35.2

data/test/unit/factory/model_stack_tests.rb

@@ -0,0 +1,97 @@
+require 'assert'
+require 'mr/factory/model_stack'
+
+require 'mr/fake_record'
+require 'mr/model'
+require 'mr/factory/model_factory'
+require 'mr/factory/record_stack'
+
+class MR::Factory::ModelStack
+
+  class UnitTests < Assert::Context
+    desc "MR::Factory::ModelStack"
+    setup do
+      @record_stack_spy = nil
+      Assert.stub(MR::Factory::RecordStack, :for_record) do |*args|
+        @record_stack_spy = RecordStackSpy.new(*args)
+      end
+
+      @record_class = Class.new{ include MR::FakeRecord }
+      @model_class  = Class.new{ include MR::Model }
+      @model_class.record_class(@record_class)
+
+      @model          = @model_class.new
+      @factory_config = MR::Factory::ModelFactory::Config.new(@record_class)
+
+      @stack_class = MR::Factory::ModelStack
+      @stack       = @stack_class.new(@model, @factory_config)
+    end
+    subject{ @stack }
+
+    should have_readers :model
+    should have_imeths :factory_config
+    should have_imeths :create, :destroy
+    should have_imeths :create_dependencies, :create_deps
+    should have_imeths :destroy_dependencies, :destroy_deps
+
+    should "know its model and factory config" do
+      assert_equal @model,          subject.model
+      assert_equal @factory_config, subject.factory_config
+    end
+
+    should "build a record stack" do
+      assert_not_nil @record_stack_spy
+      assert_equal @model.record,   @record_stack_spy.record
+      assert_equal @factory_config, @record_stack_spy.factory_config
+    end
+
+    should "demeter its record stack" do
+      assert_false @record_stack_spy.create_called
+      subject.create
+      assert_true @record_stack_spy.create_called
+
+      assert_false @record_stack_spy.destroy_called
+      subject.destroy
+      assert_true @record_stack_spy.destroy_called
+
+      assert_false @record_stack_spy.create_dependencies_called
+      subject.create_dependencies
+      assert_true @record_stack_spy.create_dependencies_called
+
+      @record_stack_spy.create_dependencies_called = false
+      subject.create_deps
+      assert_true @record_stack_spy.create_dependencies_called
+
+      assert_false @record_stack_spy.destroy_dependencies_called
+      subject.destroy_dependencies
+      assert_true @record_stack_spy.destroy_dependencies_called
+
+      @record_stack_spy.destroy_dependencies_called = false
+      subject.destroy_dependencies
+      assert_true @record_stack_spy.destroy_dependencies_called
+    end
+
+  end
+
+  class RecordStackSpy
+    attr_reader :record, :factory_config
+    attr_accessor :create_called, :destroy_called
+    attr_accessor :create_dependencies_called, :destroy_dependencies_called
+
+    def initialize(record, factory_config)
+      @record                      = record
+      @factory_config              = factory_config
+      @create_called               = false
+      @destroy_called              = false
+      @create_dependencies_called  = false
+      @destroy_dependencies_called = false
+    end
+
+    def create;  @create_called  = true; end
+    def destroy; @destroy_called = true; end
+
+    def create_dependencies;  @create_dependencies_called  = true; end
+    def destroy_dependencies; @destroy_dependencies_called = true; end
+  end
+
+end

data/test/unit/factory/read_model_factory_tests.rb

@@ -0,0 +1,195 @@
+require 'assert'
+require 'mr/factory/read_model_factory'
+
+require 'mr/json_field'
+require 'mr/read_model'
+
+class MR::Factory::ReadModelFactory
+
+  class UnitTests < Assert::Context
+    desc "MR::Factory::ReadModelFactory"
+    setup do
+      @factory_class = MR::Factory::ReadModelFactory
+    end
+    subject{ @factory_class }
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @read_model_class = TestReadModel
+      @factory          = @factory_class.new(@read_model_class)
+    end
+    subject{ @factory }
+
+    should have_readers :read_model_class, :config
+    should have_imeths :read_model_data, :read_model, :instance
+
+    should "instance eval any block it's initialized with" do
+      yielded = nil
+      factory = @factory_class.new(@read_model_class){ yielded = self }
+      assert_equal factory, yielded
+    end
+
+    should "raise an argument error if init without a read model or read model struct" do
+      assert_nothing_raised{ @factory_class.new(@read_model_class) }
+      assert_nothing_raised{ @factory_class.new(@read_model_class::StructReadModel) }
+
+      assert_raises(ArgumentError){ @factory_class.new(Factory.string) }
+    end
+
+    should "know its read model class and config" do
+      assert_equal @read_model_class, subject.read_model_class
+
+      assert_instance_of Config, subject.config
+      assert_equal subject.read_model_class, subject.config.read_model_class
+    end
+
+    should "allow configuring default args" do
+      name              = Factory.string
+      default_args_proc = proc{ set(:name, name) }
+      factory           = @factory_class.new(@read_model_class)
+
+      set_default_args_called_with = nil
+      Assert.stub(factory.config, :set_default_args) do |&block|
+        set_default_args_called_with = block
+        Assert.stub_send(factory.config, :set_default_args, &block)
+      end
+
+      factory.instance_eval{ default_args(&default_args_proc) }
+      assert_equal default_args_proc, set_default_args_called_with
+
+      read_model = factory.read_model
+      assert_equal name, read_model.name
+    end
+
+  end
+
+  class ReadModelDataTests < InitTests
+    desc "read_model_data"
+
+    should "build a read model data object" do
+      read_model_data = subject.read_model_data
+      assert_instance_of Data, read_model_data
+      assert_kind_of String, read_model_data['name']
+    end
+
+    should "apply passed args to the read model data" do
+      name            = Factory.string
+      read_model_data = subject.read_model_data(:name => name)
+      assert_equal name, read_model_data['name']
+    end
+
+    should "apply default args to the record" do
+      name = Factory.string
+      subject.config.set_default_args{ set(:name, name) }
+      read_model_data = subject.read_model_data
+      assert_equal name, read_model_data['name']
+    end
+
+    should "apply passed args over default args to the read model data" do
+      name = Factory.string
+      subject.config.set_default_args{ set(:name, name) }
+      new_name        = Factory.string
+      read_model_data = subject.read_model_data(:name => new_name)
+      assert_equal new_name, read_model_data['name']
+    end
+
+  end
+
+  class ReadModelMethodTests < InitTests
+    desc "read_model"
+    setup do
+      @read_model_data_called_with = nil
+      @built_read_model_data       = nil
+      Assert.stub(subject, :read_model_data) do |*args|
+        @read_model_data_called_with = args
+        @built_read_model_data = Assert.stub_send(subject, :read_model_data, *args)
+      end
+    end
+
+    should "build an instance of the read model clast" do
+      read_model = subject.read_model
+      assert_instance_of @read_model_class, read_model
+      assert_same @built_read_model_data, read_model.instance_eval{ read_model_data }
+    end
+
+    should "be aliased" do
+      read_model = subject.instance
+      assert_instance_of @read_model_class, read_model
+      assert_same @built_read_model_data, read_model.instance_eval{ read_model_data }
+    end
+
+    should "allow passing args when building a read model" do
+      args         = { :name => Factory.string }
+      saved_record = subject.read_model(args)
+      assert_equal [args], @read_model_data_called_with
+    end
+
+  end
+
+  class ConfigTests < UnitTests
+    desc "Config"
+    setup do
+      @config_class = Config
+    end
+    subject{ @config_class }
+
+    should "be a factory config" do
+      assert_includes MR::Factory::Config, subject
+    end
+
+  end
+
+  class ConfigInitTests < ConfigTests
+    desc "when init"
+    setup do
+      @read_model_class = TestReadModel
+      @config           = @config_class.new(@read_model_class)
+    end
+    subject{ @config }
+
+    should have_imeths :read_model_class
+
+    should "know its read model class" do
+      assert_equal @read_model_class, subject.read_model_class
+    end
+
+    should "know how to apply field default args to a read model data" do
+      read_model_data = @factory_class::Data.new
+      subject.apply_args(read_model_data, {})
+
+      assert_kind_of String, read_model_data['name']
+
+      assert_instance_of Array, read_model_data['struct_list']
+      assert_includes read_model_data['struct_list'].size, [1, 2, 3]
+
+      read_model_data['struct_list'].each do |struct_list_data|
+        assert_instance_of Data, struct_list_data
+        assert_kind_of String, struct_list_data['name']
+      end
+
+      assert_instance_of Data, read_model_data['struct_obj']
+      assert_kind_of String, read_model_data['struct_obj']['name']
+    end
+
+  end
+
+  class TestReadModel
+    include MR::ReadModel
+
+    field :name, :string
+
+    json_struct_obj :struct_obj, 'StructReadModel'
+
+    json_struct_list :struct_list, 'StructReadModel'
+
+    class StructReadModel
+      include MR::ReadModelStruct
+
+      field :name, :string
+    end
+  end
+
+end

data/test/unit/factory/record_factory_tests.rb

@@ -0,0 +1,446 @@
+require 'assert'
+require 'mr/factory/record_factory'
+
+require 'mr/factory/config'
+require 'mr/fake_record'
+require 'mr/record'
+
+class MR::Factory::RecordFactory
+
+  class UnitTests < Assert::Context
+    desc "MR::Factory::RecordFactory"
+    setup do
+      @factory_class = MR::Factory::RecordFactory
+    end
+    subject{ @factory_class }
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @record_class = FakeTwoRecord
+      @factory      = @factory_class.new(@record_class)
+    end
+    subject{ @factory }
+
+    should have_readers :record_class, :config
+    should have_imeths :record, :instance
+    should have_imeths :saved_record, :saved_instance
+    should have_imeths :stack, :instance_stack
+    should have_imeths :stack_record, :saved_stack, :saved_stack_record
+    should have_imeths :saved_dependencies_stack, :saved_deps_stack
+    should have_imeths :saved_dependencies_stack_record, :saved_deps_stack_record
+
+    should "instance eval any block it's initialized with" do
+      yielded = nil
+      factory = @factory_class.new(@record_class){ yielded = self }
+      assert_equal factory, yielded
+    end
+
+    should "know its record class and config" do
+      assert_equal @record_class, subject.record_class
+
+      assert_instance_of Config, subject.config
+      assert_equal subject.record_class, subject.config.record_class
+    end
+
+    should "allow configuring a default association" do
+      association_name   = Factory.boolean ? :fake_one : :fake_poly
+      assoc_record_class = FakeOneRecord
+      associated_factory = @factory_class.new(assoc_record_class)
+      factory = @factory_class.new(@record_class) do
+        default_association(association_name, associated_factory, {
+          :force_in_stack => true
+        })
+      end
+
+      associated_record = associated_factory.record
+      Assert.stub(associated_factory, :record){ associated_record }
+
+      assert_same associated_record, factory.config.build_associated_record(
+        association_name,
+        assoc_record_class
+      )
+
+      assert_includes association_name, factory.config.force_in_stack_association_names
+    end
+
+    should "allow configuring default args" do
+      name              = Factory.string
+      default_args_proc = proc{ set(:name, name) }
+      factory           = @factory_class.new(@record_class)
+
+      set_default_args_called_with = nil
+      Assert.stub(factory.config, :set_default_args) do |&block|
+        set_default_args_called_with = block
+        Assert.stub_send(factory.config, :set_default_args, &block)
+      end
+
+      factory.instance_eval{ default_args(&default_args_proc) }
+      assert_equal default_args_proc, set_default_args_called_with
+
+      record = factory.record
+      assert_equal name, record.name
+    end
+
+  end
+
+  class RecordMethodTests < InitTests
+    desc "record"
+    setup do
+      @built_record = nil
+      Assert.stub(@record_class, :new) do |*args|
+        @built_record = Assert.stub_send(@record_class, :new, *args)
+      end
+    end
+
+    should "return an instance of the record class" do
+      record = subject.record
+      assert_same @built_record, record
+      assert_instance_of String, record.name
+    end
+
+    should "be aliased" do
+      record = subject.instance
+      assert_same @built_record, record
+      assert_instance_of String, record.name
+    end
+
+    should "apply passed args to the record" do
+      name   = Factory.string
+      record = subject.record(:name => name)
+      assert_equal name, record.name
+    end
+
+    should "apply default args to the record" do
+      name = Factory.string
+      subject.config.set_default_args{ set(:name, name) }
+      record = subject.record
+      assert_equal name, record.name
+    end
+
+    should "apply passed args over default args to the record" do
+      name = Factory.string
+      subject.config.set_default_args{ set(:name, name) }
+      new_name  = Factory.string
+      record    = subject.record(:name => new_name)
+      assert_equal new_name, record.name
+    end
+
+  end
+
+  class SavedRecordMethodTests < InitTests
+    desc "saved_record"
+    setup do
+      @record_called_with = nil
+      @built_record       = nil
+      Assert.stub(subject, :record) do |*args|
+        @record_called_with = args
+        @built_record       = Assert.stub_send(subject, :record, *args)
+      end
+    end
+
+    should "build an instance of the record class and save it" do
+      saved_record = subject.saved_record
+      assert_same @built_record, saved_record
+      assert_false saved_record.new_record?
+    end
+
+    should "be aliased" do
+      saved_record = subject.saved_instance
+      assert_same @built_record, saved_record
+      assert_false saved_record.new_record?
+    end
+
+    should "allow passing args when building a saved record" do
+      args         = { :name => Factory.string }
+      saved_record = subject.saved_record(args)
+      assert_equal [args], @record_called_with
+    end
+
+    should "reset the fake records save called flag" do
+      assert_false subject.saved_record.save_called
+    end
+
+  end
+
+  class StackMethodTests < InitTests
+    desc "stack"
+    setup do
+      @record_called_with = nil
+      @built_record       = nil
+      Assert.stub(subject, :record) do |*args|
+        @record_called_with = args
+        @built_record       = Assert.stub_send(subject, :record, *args)
+      end
+    end
+
+    should "build a record stack" do
+      stack = subject.stack
+      assert_instance_of MR::Factory::RecordStack, stack
+      assert_equal [nil],          @record_called_with
+      assert_same  @built_record,  stack.record
+      assert_same  subject.config, stack.factory_config
+    end
+
+    should "be aliased" do
+      stack = subject.instance_stack
+      assert_instance_of MR::Factory::RecordStack, stack
+      assert_equal [nil],          @record_called_with
+      assert_same  @built_record,  stack.record
+      assert_same  subject.config, stack.factory_config
+    end
+
+    should "allow passing args when building a stack" do
+      args  = { :name => Factory.string }
+      stack = subject.stack(args)
+      assert_equal [args], @record_called_with
+    end
+
+  end
+
+  class StackRecordMethodTests < InitTests
+    desc "stack_record"
+    setup do
+      @stack_called_with = nil
+      @built_stack       = nil
+      Assert.stub(subject, :stack) do |*args|
+        @stack_called_with = args
+        @built_stack       = Assert.stub_send(subject, :stack, *args)
+      end
+    end
+
+    should "build a stack record" do
+      record = subject.stack_record
+      assert_equal [nil],               @stack_called_with
+      assert_same  @built_stack.record, record
+    end
+
+    should "allow passing args when building a stack record" do
+      args   = { :name => Factory.string }
+      record = subject.stack_record(args)
+      assert_equal [args], @stack_called_with
+    end
+
+  end
+
+  class SavedStackMethodTests < InitTests
+    desc "saved_stack"
+    setup do
+      @stack_called_with   = nil
+      @built_stack         = nil
+      @stack_create_called = false
+      Assert.stub(subject, :stack) do |*args|
+        @stack_called_with = args
+        @built_stack       = Assert.stub_send(subject, :stack, *args)
+        Assert.stub(@built_stack, :create) do
+          @stack_create_called = true
+          Assert.stub_send(@built_stack, :create)
+        end
+        @built_stack
+      end
+    end
+
+    should "build a saved stack" do
+      saved_stack = subject.saved_stack
+      assert_equal [nil],        @stack_called_with
+      assert_same  @built_stack, saved_stack
+      assert_true @stack_create_called
+    end
+
+    should "allow passing args when building a saved stack record" do
+      args        = { :name => Factory.string }
+      saved_stack = subject.saved_stack(args)
+      assert_equal [args], @stack_called_with
+    end
+
+  end
+
+  class SavedStackModelMethodTests < InitTests
+    desc "saved_stack_record"
+    setup do
+      @saved_stack_called_with = nil
+      @built_saved_stack       = nil
+      Assert.stub(subject, :saved_stack) do |*args|
+        @saved_stack_called_with = args
+        @built_saved_stack       = Assert.stub_send(subject, :saved_stack, *args)
+      end
+    end
+
+    should "build a saved stack record" do
+      saved_record = subject.saved_stack_record
+      assert_equal [nil],                     @saved_stack_called_with
+      assert_same  @built_saved_stack.record, saved_record
+    end
+
+    should "allow passing args when building a saved stack record" do
+      args         = { :name => Factory.string }
+      saved_record = subject.saved_stack_record(args)
+      assert_equal [args], @saved_stack_called_with
+    end
+
+  end
+
+  class SavedDepsStackMethodTests < InitTests
+    desc "saved_dependencies_stack"
+    setup do
+      @stack_called_with        = nil
+      @built_stack              = nil
+      @stack_create_deps_called = false
+      Assert.stub(subject, :stack) do |*args|
+        @stack_called_with = args
+        @built_stack       = Assert.stub_send(subject, :stack, *args)
+        Assert.stub(@built_stack, :create_deps) do
+          @stack_create_deps_called = true
+          Assert.stub_send(@built_stack, :create_deps)
+        end
+        @built_stack
+      end
+    end
+
+    should "build a saved dependencies stack" do
+      saved_deps_stack = subject.saved_dependencies_stack
+      assert_equal [nil],        @stack_called_with
+      assert_same  @built_stack, saved_deps_stack
+      assert_true @stack_create_deps_called
+    end
+
+    should "be aliased" do
+      saved_deps_stack = subject.saved_deps_stack
+      assert_equal [nil],        @stack_called_with
+      assert_same  @built_stack, saved_deps_stack
+      assert_true @stack_create_deps_called
+    end
+
+    should "allow passing args when building a saved dependencies stack" do
+      args             = { :name => Factory.string }
+      saved_deps_stack = subject.saved_dependencies_stack(args)
+      assert_equal [args], @stack_called_with
+    end
+
+  end
+
+  class SavedDepsStackModelTests < InitTests
+    desc "saved_dependencies_stack_record"
+    setup do
+      @saved_deps_stack_called_with = nil
+      @built_saved_deps_stack       = nil
+      Assert.stub(subject, :saved_deps_stack) do |*args|
+        @saved_deps_stack_called_with = args
+        @built_saved_deps_stack = Assert.stub_send(subject, :saved_deps_stack, *args)
+      end
+    end
+
+    should "know how to build a saved dependencies stack record" do
+      saved_deps_record = subject.saved_dependencies_stack_record
+      assert_equal [nil],                          @saved_deps_stack_called_with
+      assert_same  @built_saved_deps_stack.record, saved_deps_record
+    end
+
+    should "be aliased" do
+      saved_deps_record = subject.saved_deps_stack_record
+      assert_equal [nil],                          @saved_deps_stack_called_with
+      assert_same  @built_saved_deps_stack.record, saved_deps_record
+    end
+
+    should "allow passing args when building a saved dependencies stack record" do
+      args              = { :name => Factory.string }
+      saved_deps_record = subject.saved_dependencies_stack_record(args)
+      assert_equal [args],                         @saved_deps_stack_called_with
+      assert_same  @built_saved_deps_stack.record, saved_deps_record
+    end
+
+  end
+
+  class ConfigTests < UnitTests
+    desc "Config"
+    setup do
+      @config_class = Config
+    end
+    subject{ @config_class }
+
+    should "be a with-associations factory config" do
+      assert_includes MR::Factory::WithAssociationsConfig, subject
+    end
+
+  end
+
+  class ConfigInitTests < ConfigTests
+    desc "when init"
+    setup do
+      @record_class = FakeTwoRecord
+      @config       = @config_class.new(@record_class)
+    end
+    subject{ @config }
+
+    should have_imeths :build_associated_record, :ar_association_for
+
+    should "know how to build an associated record" do
+      factory_for_called_with = []
+      built_factory           = nil
+      record                  = nil
+      Assert.stub(subject, :factory_for) do |*args|
+        factory_for_called_with = args
+        built_factory = Assert.stub_send(subject, :factory_for, *args)
+        record = built_factory.record
+        Assert.stub(built_factory, :record){ record }
+        built_factory
+      end
+
+      association_name   = Factory.boolean ? :fake_one : :fake_poly
+      assoc_record_class = FakeOneRecord
+      result = subject.build_associated_record(
+        association_name,
+        assoc_record_class
+      )
+
+      assert_equal [association_name, assoc_record_class], factory_for_called_with
+      assert_instance_of MR::Factory::RecordFactory, built_factory
+      assert_equal assoc_record_class, built_factory.record_class
+
+      assert_same record, result
+    end
+
+    should "know how to get an activerecord association for a record" do
+      record = @record_class.new
+
+      exp = record.association(:fake_one)
+      assert_equal exp, subject.ar_association_for(record, :fake_one)
+
+      assert_nil subject.ar_association_for(record, Factory.string)
+    end
+
+    should "know how to apply column default args to a record" do
+      record = @record_class.new
+      subject.apply_args(record, {})
+
+      assert_instance_of String, record.name
+      assert_nil record.id
+      assert_nil record.fake_poly_type
+      assert_nil record.fake_poly_id
+      assert_nil record.fake_one_id
+      assert_nil record.bad_column
+    end
+
+  end
+
+  class FakeOneRecord
+    include MR::FakeRecord
+  end
+
+  class FakeTwoRecord
+    include MR::FakeRecord
+
+    attribute :name,           :string
+    attribute :fake_poly_type, :string
+    attribute :fake_poly_id,   :integer
+    attribute :fake_one_id,    :integer
+
+    attribute :bad_column, :invalid_type
+
+    belongs_to :fake_poly, :polymorphic => true
+    belongs_to :fake_one,  :class_name  => FakeOneRecord.to_s
+  end
+
+end