mr 0.35.2

data/test/unit/factory_tests.rb

@@ -0,0 +1,213 @@
+require 'assert'
+require 'mr/factory'
+
+require 'thread'
+require 'mr/fake_record'
+require 'mr/model'
+require 'mr/read_model'
+require 'mr/type_converter'
+
+module MR::Factory
+
+  class UnitTests < Assert::Context
+    desc "MR::Factory"
+    setup do
+      @type_converter = MR::TypeConverter.new
+    end
+    subject{ MR::Factory }
+
+    should have_imeths :new
+    should have_imeths :primary_key, :decimal, :timestamp
+    should have_imeths :type_converter
+
+    should "extend `Assert::Factory`" do
+      assert_respond_to :integer,   subject
+      assert_respond_to :float,     subject
+      assert_respond_to :date,      subject
+      assert_respond_to :datetime,  subject
+      assert_respond_to :time,      subject
+      assert_respond_to :string,    subject
+      assert_respond_to :text,      subject
+      assert_respond_to :slug,      subject
+      assert_respond_to :hex,       subject
+      assert_respond_to :binary,    subject
+      assert_respond_to :file_name, subject
+      assert_respond_to :dir_path,  subject
+      assert_respond_to :file_path, subject
+      assert_respond_to :boolean,   subject
+    end
+
+    should "return unique integers for an identifier using `primary_key`" do
+      assert_equal 1, subject.primary_key('test')
+      assert_equal 2, subject.primary_key('test')
+      assert_equal 1, subject.primary_key('other')
+    end
+
+    should "return a random decimal using `decimal`" do
+      assert_kind_of BigDecimal, subject.decimal
+    end
+
+    should "allow passing a maximum value using `decimal`" do
+      decimal = subject.decimal(2)
+      assert decimal <= 2
+      assert decimal >= 0
+    end
+
+    should "return a random time object using `timestamp`" do
+      assert_kind_of Time, subject.timestamp
+    end
+
+    should "return an instance of MR::TypeConverter using `type_converter`" do
+      assert_instance_of MR::TypeConverter, subject.type_converter
+    end
+
+  end
+
+  class NewTests < UnitTests
+    desc "new"
+    setup do
+      @record_factory_built_with = nil
+      Assert.stub(MR::Factory::RecordFactory, :new) do |*args, &block|
+        @record_factory_built_with = args + [block]
+        Assert.stub_send(MR::Factory::RecordFactory, :new, *args, &block)
+      end
+
+      @model_factory_built_with = nil
+      Assert.stub(MR::Factory::ModelFactory, :new) do |*args, &block|
+        @model_factory_built_with = args + [block]
+        Assert.stub_send(MR::Factory::ModelFactory, :new, *args, &block)
+      end
+
+      @read_model_factory_built_with = nil
+      Assert.stub(MR::Factory::ReadModelFactory, :new) do |*args, &block|
+        @read_model_factory_built_with = args + [block]
+        Assert.stub_send(MR::Factory::ReadModelFactory, :new, *args, &block)
+      end
+    end
+
+    should "build a record factory when passed a record class" do
+      block = proc{ Factory.string }
+
+      factory = subject.new(TestFakeRecord, &block)
+      assert_equal [TestFakeRecord, block], @record_factory_built_with
+      assert_instance_of MR::Factory::RecordFactory, factory
+    end
+
+    should "build a model factory when passed a model class" do
+      block = proc{ Factory.string }
+
+      factory = subject.new(TestFakeModel, TestFakeRecord, &block)
+      assert_equal [TestFakeModel, TestFakeRecord, block], @model_factory_built_with
+      assert_instance_of MR::Factory::ModelFactory, factory
+    end
+
+    should "build a read model factory when passed a read model class" do
+      block = proc{ Factory.string }
+
+      factory = subject.new(TestReadModel, &block)
+      assert_equal [TestReadModel, block], @read_model_factory_built_with
+      assert_instance_of MR::Factory::ReadModelFactory, factory
+    end
+
+    should "build a read model factory when passed a read model struct class" do
+      block = proc{ Factory.string }
+
+      factory = subject.new(TestReadModelStruct, &block)
+      assert_equal [TestReadModelStruct, block], @read_model_factory_built_with
+      assert_instance_of MR::Factory::ReadModelFactory, factory
+    end
+
+  end
+
+  class PrimaryKeyProviderTests < UnitTests
+    desc "PrimaryKeyProvider"
+    setup do
+      @provider   = PrimaryKeyProvider.new
+      @started_at = @provider.current
+    end
+    subject{ @provider }
+
+    should have_readers :mutex, :current
+
+    should "store a mutex and it's current value" do
+      assert_instance_of Mutex,  subject.mutex
+      assert_instance_of Fixnum, subject.current
+    end
+
+    should "increated the counter and return the value using `next`" do
+      next_id = subject.next
+      assert_equal @started_at + 1, next_id
+      assert_equal @started_at + 1, subject.current
+    end
+
+    should "lock getting the next value using `next`" do
+      threads = [*0..2].map do |n|
+        Thread.new{ Thread.current['id'] = @provider.next }
+      end
+      primary_keys = threads.map{ |thread| thread.join; thread['id'] }
+      assert_includes 1, primary_keys
+      assert_includes 2, primary_keys
+    end
+
+  end
+
+  class NoRecordClassErrorTests < UnitTests
+    desc "NoRecordClassError"
+    setup do
+      @error_class = NoRecordClassError
+    end
+    subject{ @error_class }
+
+    should have_imeths :for_association
+
+    should "be a runtime error" do
+      assert_true subject < RuntimeError
+    end
+
+    should "know how to be built for a record reflection" do
+      record         = TestFakeRecord.new
+      ar_association = record.association(:user)
+      error          = subject.for_association(ar_association)
+
+      exp = "can't build 'user' association on #{TestFakeRecord} -- try " \
+            "manually setting it or building it via a stack if you've " \
+            "configured default associations"
+      assert_equal exp, error.message
+
+      ar_association = record.association(:parent)
+      error          = subject.for_association(ar_association)
+
+      exp = "can't build 'parent' association on #{TestFakeRecord} -- try " \
+            "manually setting it, building it via a stack if you've " \
+            "configured default associations, or setting its 'parent_type' " \
+            "attribute"
+      assert_equal exp, error.message
+    end
+
+  end
+
+  class TestFakeRecord
+    include MR::FakeRecord
+
+    attribute :parent_type, :string,  :null => true
+    attribute :parent_id,   :integer, :null => true
+    attribute :user_id,     :integer
+
+    belongs_to :parent, :polymorphic => true
+    belongs_to :user,   :class_name  => 'MR::Factory::RecordFactory::TestFakeRecord'
+  end
+
+  class TestFakeModel
+    include MR::Model
+    record_class TestFakeRecord
+  end
+
+  class TestReadModel
+    include MR::ReadModel
+  end
+
+  class TestReadModelStruct
+    include MR::ReadModelStruct
+  end
+
+end

data/test/unit/fake_query_tests.rb

@@ -0,0 +1,137 @@
+require 'assert'
+require 'mr/fake_query'
+
+require 'mr/fake_record'
+require 'mr/model'
+require 'mr/query'
+
+class MR::FakeQuery
+
+  class UnitTests < Assert::Context
+    desc "MR::FakeQuery"
+    setup do
+      # +1 so we always have at least 2 results
+      @results = (Factory.integer(3) + 1).times.map do
+        FakeTestModel.new.tap(&:save)
+      end
+      @query = MR::FakeQuery.new(@results)
+    end
+    subject{ @query }
+
+    should have_readers :results, :first, :count
+    should have_imeths :results!, :first!, :count!, :paged
+
+    should "know its results and count" do
+      assert_equal @results,      subject.results
+      assert_equal @results.size, subject.count
+    end
+
+    should "default its results and count" do
+      query = MR::FakeQuery.new(nil)
+      assert_equal [], query.results
+      assert_equal 0, query.count
+    end
+
+    should "know its first result" do
+      assert_equal @results.first, subject.first
+
+      query = MR::FakeQuery.new([nil, []].sample)
+      assert_nil query.first
+    end
+
+    should "alias its results, first, and count methods" do
+      assert_same subject.results, subject.results!
+      assert_same subject.first,   subject.first!
+      assert_same subject.count,   subject.count!
+    end
+
+    should "return an instance of a `FakePagedQuery` with #paged" do
+      assert_instance_of MR::FakePagedQuery, subject.paged
+    end
+
+  end
+
+  class FakePagedQueryTests < UnitTests
+    desc "MR::FakePagedQuery"
+    setup do
+      @page_num  = Factory.integer(@results.size)
+      @page_size = 1
+
+      @paged_query_class = MR::FakePagedQuery
+      @paged_query       = @paged_query_class.new(@query, @page_num, @page_size)
+    end
+    subject{ @paged_query }
+
+    should have_readers :page_num, :page_size, :page_offset, :total_count
+    should have_imeths :total_count!, :has_next_page?, :is_last_page?
+
+    should "be a kind of MR::FakeQuery" do
+      assert_kind_of MR::FakeQuery, subject
+    end
+
+    should "know its page num/size/offset" do
+      assert_equal @page_num, subject.page_num
+      assert_equal @page_size, subject.page_size
+      exp = MR::PagedQuery::PageOffset.new(@page_num, @page_size)
+      assert_equal exp, subject.page_offset
+    end
+
+    should "know its paged results" do
+      exp = @results[subject.page_offset, subject.page_size]
+      assert_equal exp, subject.results
+    end
+
+    should "know its paged result count" do
+      assert_equal @page_size, subject.count
+    end
+
+    should "know its total number of results" do
+      assert_equal @results.size, subject.total_count
+    end
+
+    should "alias its total count" do
+      assert_same subject.total_count, subject.total_count!
+    end
+
+    should "know if it has a next page or is the last page" do
+      unpaged_results = @results.dup
+      Assert.stub(@results, :dup){ unpaged_results }
+
+      page_num    = Factory.integer(10)
+      page_size   = Factory.integer(10)
+      page_offset = MR::PagedQuery::PageOffset.new(page_num, page_size)
+      page_end    = page_offset + page_size
+
+      total_count = Factory.integer(page_size - 1) + page_end
+      Assert.stub(unpaged_results, :size){ total_count }
+      paged_query = @paged_query_class.new(@query, page_num, page_size)
+
+      assert_true  paged_query.has_next_page?
+      assert_false paged_query.is_last_page?
+
+      total_count = Factory.integer(page_size - 1) + page_offset
+      Assert.stub(unpaged_results, :size){ total_count }
+      paged_query = @paged_query_class.new(@query, page_num, page_size)
+
+      assert_false paged_query.has_next_page?
+      assert_true  paged_query.is_last_page?
+
+      Assert.stub(unpaged_results, :size){ page_end }
+      paged_query = @paged_query_class.new(@query, page_num, page_size)
+
+      assert_false paged_query.has_next_page?
+      assert_true  paged_query.is_last_page?
+    end
+
+  end
+
+  class FakeTestRecord
+    include MR::FakeRecord
+  end
+
+  class FakeTestModel
+    include MR::Model
+    record_class FakeTestRecord
+  end
+
+end

data/test/unit/fake_record/associations_tests.rb

@@ -0,0 +1,585 @@
+require 'assert'
+require 'mr/fake_record/associations'
+
+require 'much-plugin'
+require 'mr/fake_record'
+
+module MR::FakeRecord::Associations
+
+  class UnitTests < Assert::Context
+    desc "MR::FakeRecord::Associations"
+    setup do
+      @fake_record_class = Class.new do
+        include MR::FakeRecord::Associations
+      end
+    end
+    subject{ @fake_record_class }
+
+    should have_imeths :reflections
+    should have_imeths :reflect_on_association, :reflect_on_all_associations
+    should have_imeths :belongs_to, :has_one, :has_many
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, MR::FakeRecord::Associations
+    end
+
+    should "include the fake record attributes mixin" do
+      assert_includes MR::FakeRecord::Attributes, subject
+    end
+
+    should "know its reflections" do
+      reflections = subject.reflections
+      assert_instance_of MR::FakeRecord::ReflectionSet, reflections
+      assert_same reflections, subject.reflections
+    end
+
+    should "allow adding belongs to associations" do
+      add_belongs_to_called_with = nil
+      Assert.stub(subject.reflections, :add_belongs_to) do |*args|
+        add_belongs_to_called_with = args
+        Assert.stub_send(subject.reflections, :add_belongs_to, *args)
+      end
+      association_name = Factory.string
+      options          = { Factory.string => Factory.string }
+      subject.belongs_to(association_name, options)
+
+      exp = [subject, association_name, options]
+      assert_equal exp, add_belongs_to_called_with
+    end
+
+    should "allow adding has one associations" do
+      add_has_one_called_with = nil
+      Assert.stub(subject.reflections, :add_has_one) do |*args|
+        add_has_one_called_with = args
+        Assert.stub_send(subject.reflections, :add_has_one, *args)
+      end
+      association_name = Factory.string
+      options          = { Factory.string => Factory.string }
+      subject.has_one(association_name, options)
+
+      exp = [subject, association_name, options]
+      assert_equal exp, add_has_one_called_with
+    end
+
+    should "allow adding has many associations" do
+      add_has_many_called_with = nil
+      Assert.stub(subject.reflections, :add_has_many) do |*args|
+        add_has_many_called_with = args
+        Assert.stub_send(subject.reflections, :add_has_many, *args)
+      end
+      association_name = Factory.string
+      options          = { Factory.string => Factory.string }
+      subject.has_many(association_name, options)
+
+      exp = [subject, association_name, options]
+      assert_equal exp, add_has_many_called_with
+    end
+
+  end
+
+  class WithAssociationsTests < UnitTests
+    desc "with associations"
+    setup do
+      @fake_record_class.belongs_to :poly_test,       :polymorphic => true
+      @fake_record_class.belongs_to :belongs_to_test, :class_name  => FakeOneRecord.to_s
+      @fake_record_class.has_one    :has_one_test,    :class_name  => FakeOneRecord.to_s
+      @fake_record_class.has_many   :has_many_test,   :class_name  => FakeOneRecord.to_s
+    end
+
+    should "return a specific reflection using `reflect_on_association`" do
+      name = [
+        :belongs_to_test,
+        :poly_test,
+        :has_one_test,
+        :has_many_test
+      ].sample
+      reflection = subject.reflect_on_association(name)
+
+      assert_instance_of MR::FakeRecord::Reflection, reflection
+      assert_equal name, reflection.name
+    end
+
+    should "return all reflections using `reflect_on_all_associations`" do
+      reflections = subject.reflect_on_all_associations
+      assert_equal 4, reflections.size
+      reflections.each{ |r| assert_instance_of MR::FakeRecord::Reflection, r }
+      expected = [ :belongs_to_test, :poly_test, :has_one_test, :has_many_test ]
+      assert_equal expected, reflections.map(&:name)
+    end
+
+    should "only return specific kinds of reflections when a type is passed " \
+           "to `reflect_on_all_associations`" do
+      reflections = subject.reflect_on_all_associations(:belongs_to)
+      assert_equal [ :belongs_to_test, :poly_test ], reflections.map(&:name)
+      reflections = subject.reflect_on_all_associations(:has_many)
+      assert_equal [ :has_many_test ], reflections.map(&:name)
+      reflections = subject.reflect_on_all_associations(:has_one)
+      assert_equal [ :has_one_test ], reflections.map(&:name)
+    end
+
+  end
+
+  class InstanceTests < UnitTests
+    desc "for a fake record instance"
+    setup do
+      @fake_record_class.belongs_to :test, :class_name => FakeOneRecord.to_s
+      @fake_record = @fake_record_class.new
+    end
+    subject{ @fake_record }
+
+    should have_imeths :association
+
+    should "return a matching association using `association`" do
+      association = subject.association(:test)
+      reflection  = @fake_record_class.reflections.find(:test)
+      assert_equal reflection.macro, association.reflection.macro
+      assert_equal reflection.name,  association.reflection.name
+    end
+
+  end
+
+  class ReflectionSetTests < UnitTests
+    desc "ReflectionSet"
+    setup do
+      @association_set = MR::FakeRecord::ReflectionSet.new
+    end
+    subject{ @association_set }
+
+    should have_imeths :belongs_to, :has_one, :has_many
+    should have_imeths :find, :all
+    should have_imeths :add_belongs_to, :add_has_one, :add_has_many
+
+    should "know how to add a belongs to" do
+      subject.add_belongs_to(@fake_record_class, :fake_one, {
+        :class_name => FakeOneRecord.to_s
+      })
+
+      assert_equal 1, subject.belongs_to.size
+      reflection = subject.belongs_to.first
+      assert_instance_of MR::FakeRecord::Reflection, reflection
+      assert_equal :fake_one, reflection.name
+      exp = {
+        :class_name  => FakeOneRecord.to_s,
+        :foreign_key => 'fake_one_id'
+      }
+      assert_equal exp, reflection.options
+
+      fake_record = @fake_record_class.new
+      assert_respond_to :fake_one,  fake_record
+      assert_respond_to :fake_one=, fake_record
+    end
+
+    should "allow passing a foreign key when adding a belongs to" do
+      foreign_key = Factory.string
+      subject.add_belongs_to(@fake_record_class, :fake_one, {
+        :class_name  => FakeOneRecord.to_s,
+        :foreign_key => foreign_key
+      })
+
+      exp = {
+        :class_name  => FakeOneRecord.to_s,
+        :foreign_key => foreign_key
+      }
+      assert_equal exp, subject.belongs_to.first.options
+    end
+
+    should "know how to add a polymorphic belongs to" do
+      subject.add_belongs_to(@fake_record_class, :fake_poly, {
+        :polymorphic => true
+      })
+
+      assert_equal 1, subject.belongs_to.size
+      reflection = subject.belongs_to.first
+      assert_instance_of MR::FakeRecord::Reflection, reflection
+      assert_equal :fake_poly, reflection.name
+      exp = {
+        :polymorphic  => true,
+        :foreign_type => 'fake_poly_type',
+        :foreign_key  => 'fake_poly_id'
+      }
+      assert_equal exp, reflection.options
+
+      fake_record = @fake_record_class.new
+      assert_respond_to :fake_poly,  fake_record
+      assert_respond_to :fake_poly=, fake_record
+    end
+
+    should "allow passing a foreign type and key when adding a poly belongs to" do
+      foreign_type = Factory.string
+      foreign_key  = Factory.string
+      subject.add_belongs_to(@fake_record_class, :fake_poly, {
+        :polymorphic  => true,
+        :foreign_type => foreign_type,
+        :foreign_key  => foreign_key
+      })
+
+      exp = {
+        :polymorphic  => true,
+        :foreign_type => foreign_type,
+        :foreign_key  => foreign_key
+      }
+      assert_equal exp, subject.belongs_to.first.options
+    end
+
+    should "know how to add a has one" do
+      subject.add_has_one(@fake_record_class, :fake_one, {
+        :class_name => FakeOneRecord.to_s
+      })
+
+      assert_equal 1, subject.has_one.size
+      reflection = subject.has_one.first
+      assert_instance_of MR::FakeRecord::Reflection, reflection
+      assert_equal :fake_one, reflection.name
+      exp = { :class_name => FakeOneRecord.to_s }
+      assert_equal exp, reflection.options
+
+      fake_record = @fake_record_class.new
+      assert_respond_to :fake_one,  fake_record
+      assert_respond_to :fake_one=, fake_record
+    end
+
+    should "know how to add a has many" do
+      subject.add_has_many(@fake_record_class, :fake_ones, {
+        :class_name => FakeOneRecord.to_s
+      })
+
+      assert_equal 1, subject.has_many.size
+      reflection = subject.has_many.first
+      assert_instance_of MR::FakeRecord::Reflection, reflection
+      assert_equal :fake_ones, reflection.name
+      exp = { :class_name => FakeOneRecord.to_s }
+      assert_equal exp, reflection.options
+
+      fake_record = @fake_record_class.new
+      assert_respond_to :fake_ones,  fake_record
+      assert_respond_to :fake_ones=, fake_record
+    end
+
+  end
+
+  class WithAssociationsOnReflectionSetTests < ReflectionSetTests
+    desc "with associations"
+    setup do
+      @association_set.add_belongs_to(@fake_record_class, :poly_belongs_to_test, {
+        :polymorphic => true
+      })
+      @association_set.add_belongs_to(@fake_record_class, :belongs_to_test, {
+        :class_name => FakeOneRecord.to_s
+      })
+      @association_set.add_has_one(@fake_record_class, :has_one_test, {
+        :class_name => FakeOneRecord.to_s
+      })
+      @association_set.add_has_many(@fake_record_class, :has_many_test, {
+        :class_name => FakeOneRecord.to_s
+      })
+    end
+
+    should "return all belongs to reflections sorted using `belongs_to`" do
+      reflections = subject.belongs_to
+      expected = [ :belongs_to_test, :poly_belongs_to_test ]
+      assert_equal expected, reflections.map(&:name)
+    end
+
+    should "return all has one reflections sorted using `has_one`" do
+      reflections = subject.has_one
+      assert_equal [ :has_one_test ], reflections.map(&:name)
+    end
+
+    should "return all has many reflections sorted using `has_many`" do
+      reflections = subject.has_many
+      assert_equal [ :has_many_test ], reflections.map(&:name)
+    end
+
+    should "find an reflection using `find`" do
+      reflection = subject.find(:belongs_to_test)
+      assert_equal :belongs_to_test, reflection.name
+      reflection = subject.find(:poly_belongs_to_test)
+      assert_equal :poly_belongs_to_test, reflection.name
+      reflection = subject.find(:has_one_test)
+      assert_equal :has_one_test, reflection.name
+      reflection = subject.find(:has_many_test)
+      assert_equal :has_many_test, reflection.name
+
+      assert_nil subject.find(:doesnt_exist)
+    end
+
+    should "return all reflections using `all`" do
+      reflections = subject.all
+      assert_equal 4, reflections.size
+      expected = [ :belongs_to_test, :poly_belongs_to_test, :has_one_test, :has_many_test ]
+      assert_equal expected, reflections.map(&:name)
+    end
+
+    should "return all matching reflections passing a type to `all`" do
+      reflections = subject.all(:belongs_to)
+      expected = [ :belongs_to_test, :poly_belongs_to_test ]
+      assert_equal expected, reflections.map(&:name)
+      reflections = subject.all(:has_many)
+      assert_equal [ :has_many_test ], reflections.map(&:name)
+      reflections = subject.all(:has_one)
+      assert_equal [ :has_one_test ], reflections.map(&:name)
+    end
+
+  end
+
+  class ReflectionTests < UnitTests
+    desc "MR::FakeRecord::Reflection"
+    setup do
+      @reflection_class = MR::FakeRecord::Reflection
+      @reflection       = @reflection_class.new(:belongs_to, :parent, {
+        :class_name   => FakeOneRecord.to_s,
+        :foreign_key  => 'parent_id',
+        :foreign_type => 'parent_type'
+      })
+    end
+    subject{ @reflection }
+
+    should have_readers :reader_method_name, :writer_method_name
+    should have_readers :name, :macro, :options
+    should have_readers :foreign_key, :foreign_type
+    should have_imeths :association_class, :klass, :define_accessor_on
+
+    should "know its method names" do
+      assert_equal "parent",  subject.reader_method_name
+      assert_equal "parent=", subject.writer_method_name
+    end
+
+    should "know its attributes" do
+      assert_equal :parent,       subject.name
+      assert_equal :belongs_to,   subject.macro
+      assert_equal 'parent_type', subject.foreign_type
+      assert_equal 'parent_id',   subject.foreign_key
+      exp = {
+        :class_name   => FakeOneRecord.to_s,
+        :foreign_key  => subject.foreign_key,
+        :foreign_type => subject.foreign_type
+      }
+      assert_equal exp, subject.options
+    end
+
+    should "return its association class using `association_class`" do
+      reflection = @reflection_class.new(:belongs_to, :test, :polymorphic => true)
+      exp = MR::FakeRecord::PolymorphicBelongsToAssociation
+      assert_equal exp, reflection.association_class
+
+      reflection = @reflection_class.new(:belongs_to, :test)
+      exp = MR::FakeRecord::BelongsToAssociation
+      assert_equal exp, reflection.association_class
+
+      reflection = @reflection_class.new(:has_one, :test)
+      exp = MR::FakeRecord::HasOneAssociation
+      assert_equal exp, reflection.association_class
+
+      reflection = @reflection_class.new(:has_many, :test)
+      exp = MR::FakeRecord::HasManyAssociation
+      assert_equal exp, reflection.association_class
+    end
+
+    should "return its class names constantized with `klass`" do
+      assert_equal FakeOneRecord, subject.klass
+    end
+
+    should "define accessor methods using `define_accessor_on`" do
+      subject.define_accessor_on(@fake_record_class)
+      fake_record = @fake_record_class.new
+
+      assert_respond_to :parent,  fake_record
+      assert_respond_to :parent=, fake_record
+    end
+
+    should "be sortable" do
+      reflections = [
+        MR::FakeRecord::Reflection.new(:belongs_to, Factory.string),
+        MR::FakeRecord::Reflection.new(:has_one,    Factory.string),
+        MR::FakeRecord::Reflection.new(:has_many,   Factory.string)
+      ].shuffle.sort
+      exp = [:belongs_to, :has_many, :has_one]
+      assert_equal exp, reflections.map(&:macro)
+    end
+
+  end
+
+  class WithFakeRecordTests < UnitTests
+    setup do
+      @fake_record_class.class_eval do
+        attr_reader :test, :tests
+        attr_accessor :parent_type, :parent_id
+      end
+      @fake_record = @fake_record_class.new
+    end
+    subject{ @association }
+
+  end
+
+  class AssociationTests < WithFakeRecordTests
+    desc "Association"
+    setup do
+      @reflection = MR::FakeRecord::Reflection.new(:belongs_to, :test)
+      @association = MR::FakeRecord::Association.new(@fake_record, @reflection)
+    end
+
+    should have_readers :owner, :reflection
+    should have_imeths :read, :write, :klass
+
+    should "know its owner and reflection" do
+      assert_equal @fake_record, subject.owner
+      assert_equal @reflection,  subject.reflection
+    end
+
+    should "return its reflection's klass using `klass`" do
+      assert_equal @reflection.klass, subject.klass
+    end
+
+    should "raise NotImplementedError using `read` and `write`" do
+      assert_raises(NotImplementedError){ subject.read }
+      assert_raises(NotImplementedError){ subject.write('test') }
+    end
+
+    should "be sortable" do
+      reflections = [
+        MR::FakeRecord::Reflection.new(:belongs_to, :belongs_to_test),
+        MR::FakeRecord::Reflection.new(:has_many,   :has_many_test)
+      ]
+      associations = reflections.map do |reflection|
+        MR::FakeRecord::Association.new(@fake_record, reflection)
+      end
+      association_names = associations.sort.map{ |a| a.reflection.name }
+      assert_equal reflections.sort.map(&:name), association_names
+    end
+
+  end
+
+  class OneToOneAssociationTests < WithFakeRecordTests
+    desc "OneToOneAssociation"
+    setup do
+      @reflection = MR::FakeRecord::Reflection.new(:belongs_to, :test)
+      @association = MR::FakeRecord::OneToOneAssociation.new(
+        @fake_record,
+        @reflection
+      )
+    end
+
+    should "be a kind of association" do
+      assert_kind_of MR::FakeRecord::Association, subject
+    end
+
+    should "read and write its value using `read` and `write`" do
+      associated_record = FakeOneRecord.new
+      subject.write(associated_record)
+      assert_same associated_record, @fake_record.test
+      assert_same @fake_record.test, subject.read
+    end
+
+  end
+
+  class OneToManyAssociationTests < WithFakeRecordTests
+    desc "OneToManyAssociation"
+    setup do
+      @reflection = MR::FakeRecord::Reflection.new(:has_many, :tests)
+      @association = MR::FakeRecord::OneToManyAssociation.new(
+        @fake_record,
+        @reflection
+      )
+    end
+
+    should "be a kind of association" do
+      assert_kind_of MR::FakeRecord::Association, subject
+    end
+
+    should "return an empty array when the association hasn't been set using `read`" do
+      assert_equal [], subject.read
+    end
+
+    should "read and write its value using `read` and `write`" do
+      associated_records = [FakeOneRecord.new]
+      subject.write(associated_records)
+      assert_equal associated_records, @fake_record.tests
+      assert_equal @fake_record.tests, subject.read
+    end
+
+    should "allow writing non-array values using `write`" do
+      associated_record = FakeOneRecord.new
+      subject.write(associated_record)
+      assert_equal [associated_record], @fake_record.tests
+    end
+
+    should "allow writing nil values using `write`" do
+      subject.write nil
+      assert_equal [], @fake_record.tests
+    end
+
+  end
+
+  class BelongsToAssociationTests < WithFakeRecordTests
+    desc "BelongsToAssociation"
+    setup do
+      @reflection = MR::FakeRecord::Reflection.new(:belongs_to, :parent, {
+        :foreign_key => 'parent_id'
+      })
+      @association = MR::FakeRecord::BelongsToAssociation.new(
+        @fake_record,
+        @reflection
+      )
+    end
+
+    should "be a kind of one to one association" do
+      assert_kind_of MR::FakeRecord::OneToOneAssociation, subject
+    end
+
+    should "write its foreign key using `write`" do
+      associated_record = FakeOneRecord.new.tap(&:save!)
+      subject.write(associated_record)
+      assert_equal associated_record.id, @fake_record.parent_id
+    end
+
+    should "allow writing nil values using `write`" do
+      subject.write nil
+      assert_equal nil, @fake_record.parent_id
+    end
+
+  end
+
+  class PolymorphicBelongsToAssociationTests < WithFakeRecordTests
+    desc "PolymorphicBelongsToAssociation"
+    setup do
+      @reflection = MR::FakeRecord::Reflection.new(:belongs_to, :parent, {
+        :foreign_type => 'parent_type',
+        :foreign_key  => 'parent_id'
+      })
+      @association = MR::FakeRecord::PolymorphicBelongsToAssociation.new(
+        @fake_record,
+        @reflection
+      )
+    end
+
+    should "be a kind of belongs to association" do
+      assert_kind_of MR::FakeRecord::BelongsToAssociation, subject
+    end
+
+    should "constantize its foreign type using `klass`" do
+      @fake_record.parent_type = FakeOneRecord.to_s
+      assert_equal FakeOneRecord, subject.klass
+    end
+
+    should "return `nil` if its foreign type isn't set using `klass`" do
+      assert_nil subject.klass
+    end
+
+    should "write its foreign type using `write`" do
+      associated_record = FakeOneRecord.new.tap(&:save!)
+      subject.write(associated_record)
+      assert_equal FakeOneRecord.to_s, @fake_record.parent_type
+    end
+
+    should "allow writing nil values using `write`" do
+      subject.write nil
+      assert_equal nil, @fake_record.parent_type
+    end
+
+  end
+
+  class FakeOneRecord
+    include MR::FakeRecord
+  end
+
+end