mr 0.35.2

data/test/unit/model/associations_tests.rb

@@ -0,0 +1,346 @@
+require 'assert'
+require 'mr/model/associations'
+
+require 'much-plugin'
+require 'mr/fake_record'
+require 'mr/model'
+
+module MR::Model::Associations
+
+  class UnitTests < Assert::Context
+    desc "MR::Model::Associations"
+    setup do
+      @model_class = Class.new do
+        include MR::Model::Associations
+        record_class FakeRecordWithAssociations
+        def initialize(record); set_record record; end
+      end
+      @record = FakeRecordWithAssociations.new
+    end
+    subject{ @model_class }
+
+    should have_imeths :associations
+    should have_imeths :belongs_to, :polymorphic_belongs_to
+    should have_imeths :has_one, :has_many
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, MR::Model::Associations
+    end
+
+    should "include Model::Configuration mixin" do
+      assert_includes MR::Model::Configuration, subject.included_modules
+    end
+
+    should "return an instance of a AssociationSet using `associations`" do
+      associations = subject.associations
+      assert_instance_of MR::Model::AssociationSet, associations
+      assert_same associations, subject.associations
+    end
+
+    should "add accessors methods for a belongs to association using `belongs_to`" do
+      subject.belongs_to :area
+      model = subject.new(@record)
+      new_record = FakeTestRecord.new
+      new_model  = FakeTestModel.new(new_record)
+
+      assert_respond_to :area, model
+      assert_respond_to :area=, model
+      model.area = new_model
+      assert_instance_of FakeTestModel, model.area
+      assert_equal new_record, @record.area
+    end
+
+    should "add accessors methods for a polymorphic belongs to association " \
+           "using `polymorphic_belongs_to`" do
+      subject.polymorphic_belongs_to :parent
+      model = subject.new(@record)
+      new_record = FakeTestRecord.new
+      new_model  = FakeTestModel.new(new_record)
+
+      assert_respond_to :parent, model
+      assert_respond_to :parent=, model
+      model.parent = new_model
+      assert_instance_of FakeTestModel, model.parent
+      assert_equal new_record, @record.parent
+    end
+
+    should "add accessors methods for a has one association using `has_one`" do
+      subject.has_one :image
+      model = subject.new(@record)
+      new_record = FakeTestRecord.new
+      new_model  = FakeTestModel.new(new_record)
+
+      assert_respond_to :image, model
+      assert_respond_to :image=, model
+      model.image = new_model
+      assert_instance_of FakeTestModel, model.image
+      assert_equal new_record, @record.image
+    end
+
+    should "add accessors methods for a has many association using `has_many`" do
+      subject.has_many :comments
+      model = subject.new(@record)
+      first_record  = FakeTestRecord.new
+      first_model   = FakeTestModel.new(first_record)
+      second_record = FakeTestRecord.new
+      second_model  = FakeTestModel.new(second_record)
+
+      assert_respond_to :comments, model
+      assert_respond_to :comments=, model
+      model.comments = [ first_model, second_model ]
+      assert_instance_of Array, model.comments
+      assert_includes first_record,  @record.comments
+      assert_includes second_record, @record.comments
+    end
+
+  end
+
+  class InstanceTests < UnitTests
+    desc "for a model instance"
+    setup do
+      @model_class.class_eval do
+        belongs_to :area
+        polymorphic_belongs_to :parent
+        has_one :image
+        has_many :comments
+      end
+      @model = @model_class.new(@record)
+    end
+    subject{ @model }
+
+    should "raise an ArgumentError if writing non MR::Model values to associations" do
+      assert_raises(ArgumentError){ subject.area = 'test' }
+      assert_raises(ArgumentError){ subject.parent = 'test' }
+      assert_raises(ArgumentError){ subject.image = 'test' }
+      assert_raises(ArgumentError){ subject.comments = [ 'test' ] }
+    end
+
+  end
+
+  class AssociationSetTests < UnitTests
+    desc "AssociationSet"
+    setup do
+      @association_set = MR::Model::AssociationSet.new
+    end
+    subject{ @association_set }
+
+    should have_readers :belongs_to, :polymorphic_belongs_to
+    should have_readers :has_one, :has_many
+    should have_imeths :add_belongs_to, :add_polymorphic_belongs_to
+    should have_imeths :add_has_one, :add_has_many
+
+  end
+
+  class AssociationTests < UnitTests
+    desc "Association"
+    setup do
+      @association = MR::Model::Association.new(:test)
+    end
+    subject{ @association }
+
+    should have_readers :name
+    should have_readers :reader_method_name, :writer_method_name
+
+    should "know it's name and method names" do
+      assert_equal 'test',  subject.name
+      assert_equal 'test',  subject.reader_method_name
+      assert_equal 'test=', subject.writer_method_name
+    end
+
+  end
+
+  class OneToOneAssociationTests < UnitTests
+    desc "OneToOneAssociation"
+    setup do
+      @test_record  = FakeTestRecord.new.tap{ |r| r.save! }
+      @test_model   = FakeTestModel.new(@test_record)
+      @other_record = FakeTestRecord.new.tap{ |r| r.save! }
+      @other_model  = FakeTestModel.new(@other_record)
+
+      @association  = MR::Model::OneToOneAssociation.new(:area)
+    end
+    subject{ @association }
+
+    should have_imeths :read, :write
+
+    should "be a kind of Association" do
+      assert_kind_of MR::Model::Association, subject
+    end
+
+    should "allow reading the record's association using `read`" do
+      @test_record.area = @other_record
+      assert_equal @other_model, subject.read(@test_record)
+    end
+
+    should "allow reading `nil` values for the record's association using `read`" do
+      @test_record.area = nil
+      assert_nil subject.read(@test_record)
+    end
+
+    should "allow writing the record's association using `write`" do
+      record  = @other_record
+      yielded = nil
+      result = subject.write(@other_model, @test_model, @test_record) do |object|
+        yielded = object; record
+      end
+
+      assert_equal @other_model,  yielded
+      assert_equal @other_record, @test_record.area
+      assert_equal @test_model.send(subject.name), result
+    end
+
+    should "allow writing `nil` values to the record's association using `write`" do
+      subject.write(nil, @test_model, @test_record){ raise 'test' }
+      assert_nil @test_record.area
+    end
+
+    should "raise a bad association value error when writing a non MR::Model" do
+      assert_raises(MR::Model::BadAssociationValueError) do
+        subject.write('test', @test_model, @test_record){ }
+      end
+    end
+
+  end
+
+  class OneToManyAssociationTests < UnitTests
+    desc "OneToManyAssociation"
+    setup do
+      @test_record   = FakeTestRecord.new.tap{ |r| r.save! }
+      @test_model    = FakeTestModel.new(@test_record)
+      @first_record  = FakeTestRecord.new.tap{ |r| r.save! }
+      @first_model   = FakeTestModel.new(@first_record)
+      @second_record = FakeTestRecord.new.tap{ |r| r.save! }
+      @second_model  = FakeTestModel.new(@second_record)
+
+      @association   = MR::Model::OneToManyAssociation.new(:comments)
+    end
+    subject{ @association }
+
+    should have_imeths :read, :write
+
+    should "be a kind of Association" do
+      assert_kind_of MR::Model::Association, subject
+    end
+
+    should "allow reading the record's association using `read`" do
+      @test_record.comments = [ @first_record ]
+      expected = [ @first_model ]
+      assert_equal expected, subject.read(@test_record)
+    end
+
+    should "allow reading `nil` values for the record's association using `read`" do
+      @test_record.comments = []
+      assert_equal [], subject.read(@test_record)
+    end
+
+    should "allow writing the record's association using `write`" do
+      models  = [ @first_model, @second_model ]
+      yielded = []
+      results = subject.write(models, @test_model, @test_record) do |object|
+        yielded << object; object.record
+      end
+
+      assert_equal models,  yielded
+      records = [ @first_record, @second_record ]
+      assert_equal records, @test_record.comments
+      assert_equal @test_model.send(subject.name), results
+    end
+
+    should "allow writing a single value to the record's association using `write`" do
+      subject.write(@second_model, @test_model, @test_record) do |object|
+        object.record
+      end
+      assert_equal [ @second_record ], @test_record.comments
+    end
+
+    should "allow writing `nil` values to the record's association using `write`" do
+      subject.write(nil, @test_model, @test_record){ raise 'test' }
+      assert_equal [], @test_record.comments
+    end
+
+    should "raise a bad association value error when writing a non MR::Model" do
+      assert_raises(MR::Model::BadAssociationValueError) do
+        subject.write('test', @test_model, @test_record){ }
+      end
+    end
+
+  end
+
+  class BelongsToAssociationTests < UnitTests
+    desc "BelongsToAssociation"
+    setup do
+      @association = MR::Model::BelongsToAssociation.new(:test)
+    end
+    subject{ @association }
+
+    should "be a kind of OneToOneAssociation" do
+      assert_kind_of MR::Model::OneToOneAssociation, subject
+    end
+
+  end
+
+  class HasOneAssociationTests < UnitTests
+    desc "HasOneAssociation"
+    setup do
+      @association = MR::Model::HasOneAssociation.new(:test)
+    end
+    subject{ @association }
+
+    should "be a kind of OneToOneAssociation" do
+      assert_kind_of MR::Model::OneToOneAssociation, subject
+    end
+
+  end
+
+  class HasManyAssociationTests < UnitTests
+    desc "HasManyAssociation"
+    setup do
+      @association = MR::Model::HasManyAssociation.new(:test)
+    end
+    subject{ @association }
+
+    should "be a kind of OneToManyAssociation" do
+      assert_kind_of MR::Model::OneToManyAssociation, subject
+    end
+
+  end
+
+  class PolymorphicBelongsToAssociationTests < UnitTests
+    desc "PolymorphicBelongsToAssociation"
+    setup do
+      @association = MR::Model::PolymorphicBelongsToAssociation.new(:test)
+    end
+    subject{ @association }
+
+    should "be a kind of BelongsToAssociation" do
+      assert_kind_of MR::Model::BelongsToAssociation, subject
+    end
+
+  end
+
+  class FakeRecordWithAssociations
+    include MR::FakeRecord
+    attribute :area_id, :integer
+    attribute :parent_type, :string
+    attribute :parent_id, :integer
+    belongs_to :area,   :class_name  => 'MR::Model::Associations::FakeRecordWithAssociations'
+    belongs_to :parent, :polymorphic => true
+    has_one :image,     :class_name  => 'MR::Model::Associations::FakeRecordWithAssociations'
+    has_many :comments, :class_name  => 'MR::Model::Associations::FakeRecordWithAssociations'
+  end
+
+  class FakeTestRecord
+    include MR::FakeRecord
+    attribute :area_id, :integer
+    belongs_to :area,   :class_name => 'MR::Model::Associations::FakeTestRecord'
+    has_many :comments, :class_name => 'MR::Model::Associations::FakeTestRecord'
+  end
+
+  class FakeTestModel
+    include MR::Model
+    record_class FakeTestRecord
+    belongs_to :area
+    has_many :comments
+  end
+
+end

data/test/unit/model/configuration_tests.rb

@@ -0,0 +1,92 @@
+require 'assert'
+require 'mr/model/configuration'
+
+require 'much-plugin'
+require 'mr/fake_record'
+
+module MR::Model::Configuration
+
+  class UnitTests < Assert::Context
+    desc "MR::Model::Configuration"
+    setup do
+      @model_class = Class.new do
+        include MR::Model::Configuration
+      end
+    end
+    subject{ @model_class }
+
+    should have_imeths :record_class
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, MR::Model::Configuration
+    end
+
+    should "allow reading and writing it's record class with `record_class`" do
+      subject.record_class FakeTestRecord
+      assert_equal FakeTestRecord, subject.record_class
+    end
+
+    should "raise a no record class error if a record class hasn't been set" do
+      assert_raises(MR::Model::NoRecordClassError){ subject.record_class }
+    end
+
+    should "raise an ArgumentError when a non MR::Record `record_class` is written" do
+      assert_raises(ArgumentError){ subject.record_class('fake-class') }
+    end
+
+  end
+
+  class InstanceTests < UnitTests
+
+    # These private methods are tested because they are an interace to the other
+    # mixins.
+
+    desc "for a model instance"
+    setup do
+      @model_class.class_eval do
+        record_class FakeTestRecord
+
+        def read_record
+          record
+        end
+
+        def write_record(record)
+          set_record(record)
+        end
+      end
+      @record = FakeTestRecord.new
+      @model  = @model_class.new
+    end
+    subject{ @model }
+
+    should have_imeths :record_class
+
+    should "allow reading the model class' record class using `record_class`" do
+      assert_equal @model_class.record_class, subject.record_class
+    end
+
+    should "allow reading the `record` through the protected method" do
+      subject.write_record(@record)
+      assert_equal @record, subject.read_record
+    end
+
+    should "set the record's model when `set_record` is called" do
+      subject.write_record(@record)
+      assert_equal @model, @record.model
+    end
+
+    should "raise a no record error if a record hasn't been set" do
+      assert_raises(MR::Model::NoRecordError){ subject.read_record }
+    end
+
+    should "raise an invalid record error when setting record without an MR::Record" do
+      assert_raises(MR::Model::InvalidRecordError){ subject.write_record('fake') }
+    end
+
+  end
+
+  class FakeTestRecord
+    include MR::FakeRecord
+  end
+
+end

data/test/unit/model/fields_tests.rb

@@ -0,0 +1,278 @@
+require 'assert'
+require 'mr/model/fields'
+
+require 'much-plugin'
+require 'mr/fake_record'
+
+module MR::Model::Fields
+
+  class UnitTests < Assert::Context
+    desc "MR::Model::Fields"
+    setup do
+      @model_class = Class.new do
+        include MR::Model::Fields
+        def initialize(record); set_record record; end
+      end
+      @record = FakeTestRecord.new
+    end
+    subject{ @model_class }
+
+    should have_imeths :fields, :field_reader, :field_writer, :field_accessor
+    should have_imeths :field_names
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, MR::Model::Fields
+    end
+
+    should "include Model::Configuration mixin" do
+      assert_includes MR::Model::Configuration, subject
+    end
+
+    should "return an instance of a FieldSet using `fields`" do
+      fields = subject.fields
+      assert_instance_of MR::Model::FieldSet, fields
+      assert_same fields, subject.fields
+    end
+
+    should "add reader methods for a field using `field_reader`" do
+      subject.field_reader :name
+      @record.name = 'test'
+      model = subject.new(@record)
+
+      assert_respond_to :name, model
+      assert_respond_to :name_was, model
+      assert_respond_to :name_changed?, model
+      assert_equal @record.name, model.name
+      assert_equal @record.name_was, model.name_was
+      assert_equal @record.name_changed?, model.name_changed?
+    end
+
+    should "add writer methods for a field using `field_writer`" do
+      subject.field_writer :name
+      model = subject.new(@record)
+
+      assert_respond_to :name=, model
+      model.name = 'test'
+      assert_equal 'test', @record.name
+    end
+
+    should "add accessor methods for a field using `field_accessor`" do
+      subject.field_accessor :name
+      model = subject.new(@record)
+
+      assert_respond_to :name, model
+      assert_respond_to :name_changed?, model
+      assert_respond_to :name=, model
+      model.name = 'test'
+      assert_equal 'test', @record.name
+      assert_equal @record.name, model.name
+      assert_equal @record.name_changed?, model.name_changed?
+    end
+
+    should "know its field names" do
+      assert_equal [], subject.field_names
+
+      subject.field_reader   :field1
+      subject.field_writer   :field2
+      subject.field_accessor :field3
+
+      result = subject.field_names
+      assert_equal subject.fields.names, result
+    end
+
+  end
+
+  class InstanceTests < UnitTests
+    desc "for a model instance"
+    setup do
+      @model_class.class_eval do
+        field_accessor :name, :active, :description
+      end
+      @model = @model_class.new(@record)
+    end
+    subject{ @model }
+
+    should have_imeths :fields, :fields=
+
+    should "allow reading all the fields using `fields`" do
+      subject.name = 'test'
+      subject.active = true
+      subject.description = 'desc'
+
+      expected = {
+        'name'        => 'test',
+        'active'      => true,
+        'description' => 'desc'
+      }
+      assert_equal expected, subject.fields
+    end
+
+    should "allow writing multiple fields using `fields=`" do
+      subject.fields = {
+        'name'        => 'test',
+        'active'      => true,
+        'description' => 'desc'
+      }
+      assert_equal 'test', subject.name
+      assert_equal true,   subject.active
+      assert_equal 'desc', subject.description
+    end
+
+    should "raise an ArgumentError when a non-Hash is passed to `fields=`" do
+      assert_raises(ArgumentError){ subject.fields = 'test' }
+    end
+
+    should "raise a no field error when writing a bad field using `fields=`" do
+      assert_raises(MR::Model::NoFieldError) do
+        subject.fields = { :not_valid => 'test' }
+      end
+    end
+
+  end
+
+  class FieldSetTests < UnitTests
+    desc "FieldSet"
+    setup do
+      @fields_set = MR::Model::FieldSet.new
+    end
+    subject{ @fields_set }
+
+    should have_imeths :names, :find, :get
+    should have_imeths :read_all, :batch_write
+    should have_imeths :add_reader, :add_writer
+
+    should "know its field names" do
+      assert_equal [], subject.names
+
+      subject.add_reader(:field1, @model_class)
+      subject.add_writer(:field2, @model_class)
+
+      assert_equal 2, subject.names.size
+      assert_includes 'field1', subject.names
+      assert_includes 'field2', subject.names
+    end
+
+    should "return an existing field or raise a no field error using `find`" do
+      subject.get('name')
+      field = subject.find('name')
+      assert_instance_of MR::Model::Field, field
+      assert_equal 'name', field.name
+
+      assert_raises(MR::Model::NoFieldError){ subject.find('not_valid') }
+    end
+
+    should "return an existing field or build a new field using `get`" do
+      field = subject.get('name')
+      assert_instance_of MR::Model::Field, field
+      assert_equal 'name', field.name
+      assert_same field, subject.get('name')
+    end
+
+    should "return a hash of field names and values using `read_all`" do
+      assert_equal({}, subject.read_all(@record))
+      subject.get('name')
+      @record.name = 'test'
+      assert_equal({ 'name' => 'test' }, subject.read_all(@record))
+    end
+
+    should "set multiple field values using `batch_write`" do
+      subject.get('name')
+      subject.get('active')
+      values = { :name => 'test', :active => true }
+      subject.batch_write(values, @record)
+
+      assert_equal 'test', @record.name
+      assert_equal true,   @record.active
+    end
+
+    should "add a field and define reader methods for it using `add_reader`" do
+      subject.add_reader('name', @model_class)
+
+      assert_instance_of MR::Model::Field, subject.find('name')
+      model = @model_class.new(@record)
+      assert_respond_to :name, model
+      assert_respond_to :name_changed?, model
+    end
+
+    should "add a field and define writer methods for it using `add_writer`" do
+      subject.add_writer('name', @model_class)
+
+      assert_instance_of MR::Model::Field, subject.find('name')
+      model = @model_class.new(@record)
+      assert_respond_to :name=, model
+    end
+
+  end
+
+  class FieldTests < UnitTests
+    desc "Field"
+    setup do
+      @field = MR::Model::Field.new('name')
+    end
+    subject{ @field }
+
+    should have_readers :name
+    should have_readers :reader_method_name, :writer_method_name
+    should have_readers :was_method_name, :changed_method_name
+
+    should have_imeths :read, :write, :was, :changed?
+    should have_imeths :define_reader_on, :define_writer_on
+
+    should "know it's name and method names" do
+      assert_equal 'name',          subject.name
+      assert_equal 'name',          subject.reader_method_name
+      assert_equal 'name_was',      subject.was_method_name
+      assert_equal 'name_changed?', subject.changed_method_name
+      assert_equal 'name=',         subject.writer_method_name
+    end
+
+    should "read a record's attribute using `read`" do
+      @record.name = 'test'
+      assert_equal 'test', subject.read(@record)
+    end
+
+    should "write a record's attribute using `write`" do
+      subject.write('test', @record)
+      assert_equal 'test', @record.name
+    end
+
+    should "read a record attribute's prevous value using `was`" do
+      assert_nil subject.was(@record)
+      @record.name = 'Test'
+      assert_nil subject.was(@record)
+      @record.save!
+      assert_equal 'Test', subject.was(@record)
+      @record.name = 'New test'
+      assert_equal 'Test', subject.was(@record)
+    end
+
+    should "return if a record's attribute has changed using `changed`" do
+      assert_equal false, subject.changed?(@record)
+      subject.write('test', @record)
+      assert_equal true, subject.changed?(@record)
+    end
+
+    should "define reader methods using `define_reader_on`" do
+      subject.define_reader_on(@model_class)
+      model = @model_class.new(@record)
+      assert_respond_to :name, model
+      assert_respond_to :name_was, model
+      assert_respond_to :name_changed?, model
+    end
+
+    should "define writer methods using `define_writer_on`" do
+      subject.define_writer_on(@model_class)
+      model = @model_class.new(@record)
+      assert_respond_to :name=, model
+    end
+
+  end
+
+  class FakeTestRecord
+    include MR::FakeRecord
+    attribute :name,        :string
+    attribute :active,      :boolean
+    attribute :description, :text
+  end
+
+end