mr 0.35.2

data/test/system/factory/record_factory_tests.rb

@@ -0,0 +1,84 @@
+require 'assert'
+require 'mr/factory/record_factory'
+
+require 'test/support/setup_test_db'
+require 'test/support/models/area'
+require 'test/support/models/user'
+
+class MR::Factory::RecordFactory
+
+  class SystemTests < DbTests
+    desc "MR::Factory::Model"
+    setup do
+      @factory_class = MR::Factory::RecordFactory
+    end
+
+  end
+
+  class BuildingRealRecordTests < SystemTests
+    setup do
+      @factory = @factory_class.new(UserRecord)
+    end
+    subject{ @factory }
+
+    should "build a record with its attributes set using `record`" do
+      user_record = subject.record
+      assert_instance_of UserRecord, user_record
+      assert_true user_record.new_record?
+      assert_kind_of String,  user_record.name
+      assert_kind_of Integer, user_record.number
+      assert_kind_of Date,    user_record.started_on
+      assert_kind_of Time,    user_record.dob
+      assert_true user_record.salary.kind_of?(Float) || user_record.salary.kind_of?(BigDecimal)
+      assert_nil user_record.area_id
+    end
+
+    should "use the `sql_type` if there is no ActiveRecord `type`" do
+      # we have to undefine attribute methods to remove any casting that was
+      # cached by ActiveRecord, thus allowing us to write a String to the
+      # 'number' field which casts its inputs to Integer.
+      UserRecord.undefine_attribute_methods
+      number_column = UserRecord.columns.detect{ |c| c.name == "number" }
+      Assert.stub(number_column, :type){ nil }
+      Assert.stub(number_column, :sql_type){ 'string' }
+
+      user_record = @factory_class.new(UserRecord).record
+      assert_kind_of String, user_record.number
+    end
+
+    should "avoid setting a field if either `type` or `sql_type` is invalid" do
+      number_column = UserRecord.columns.detect{ |c| c.name == "number" }
+      Assert.stub(number_column, :type){ Factory.string }
+
+      user_record = @factory_class.new(UserRecord).record
+      assert_nil user_record.number
+
+      Assert.stub(number_column, :type){ nil }
+      Assert.stub(number_column, :sql_type){ Factory.string }
+
+      user_record = @factory_class.new(UserRecord).record
+      assert_nil user_record.number
+
+      Assert.stub(number_column, :type){ nil }
+      Assert.stub(number_column, :sql_type){ nil }
+
+      user_record = @factory_class.new(UserRecord).record
+      assert_nil user_record.number
+    end
+
+    should "build a record and save it using `saved_record`" do
+      area_factory = @factory_class.new(AreaRecord)
+      area_record = area_factory.record.tap(&:save)
+
+      user_record = subject.saved_record(:area => area_record)
+      assert_instance_of UserRecord, user_record
+      assert_false user_record.new_record?
+    end
+
+    should "build a record stack for an instance using `stack`" do
+      assert_instance_of MR::Factory::RecordStack, subject.stack
+    end
+
+  end
+
+end

data/test/system/factory/record_stack_tests.rb

@@ -0,0 +1,51 @@
+require 'assert'
+require 'mr/factory/record_stack'
+
+require 'test/support/setup_test_db'
+require 'test/support/models/comment'
+
+class MR::Factory::RecordStack
+
+  class SystemTests < DbTests
+    desc "MR::Factory::RecordStack"
+    setup do
+      @comment_record = CommentRecord.new(:parent_type => 'UserRecord')
+      @factory_config = MR::Factory::RecordFactory::Config.new(@comment_record.class)
+
+      @record_stack = MR::Factory::RecordStack.for_record(
+        @comment_record,
+        @factory_config
+      )
+    end
+    subject{ @record_stack }
+
+    should "build an instance of the model with all " \
+           "belongs to associations set" do
+      assert_instance_of CommentRecord, @comment_record
+      assert_true @comment_record.new_record?
+      assert_instance_of UserRecord, @comment_record.parent
+      assert_true @comment_record.parent.new_record?
+      assert_instance_of AreaRecord, @comment_record.parent.area
+      assert_true @comment_record.parent.area.new_record?
+    end
+
+    should "be able to create all the records and set foreign keys" do
+      assert_nothing_raised{ subject.create }
+      assert_false @comment_record.new_record?
+      assert_false @comment_record.parent.new_record?
+      assert_equal @comment_record.parent.id, @comment_record.parent_id
+      assert_false @comment_record.parent.area.new_record?
+      assert_equal @comment_record.parent.area_id, @comment_record.parent.area.id
+    end
+
+    should "be able to destroy all the records" do
+      subject.create
+      assert_nothing_raised{ subject.destroy }
+      assert_true @comment_record.destroyed?
+      assert_true @comment_record.parent.destroyed?
+      assert_true @comment_record.parent.area.destroyed?
+    end
+
+  end
+
+end

data/test/system/factory_tests.rb

@@ -0,0 +1,32 @@
+require 'assert'
+require 'mr/factory'
+
+require 'test/support/models/user'
+
+module MR::Factory
+
+  class SystemTests < Assert::Context
+    desc "MR::Factory for records and models"
+    subject{ MR::Factory }
+
+    should "return a RecordFactory when a Record is passed to `new`" do
+      factory = subject.new(UserRecord)
+      assert_instance_of MR::Factory::RecordFactory, factory
+    end
+
+    should "return a ModelFactory when a Model is passed to `new`" do
+      factory = subject.new(User, UserRecord)
+      assert_instance_of MR::Factory::ModelFactory, factory
+      factory = subject.new(User, FakeUserRecord)
+      assert_instance_of MR::Factory::ModelFactory, factory
+    end
+
+    should "return a ReadModelFactory when a ReadModel is passed to `new`" do
+      read_model_class = Class.new{ include MR::ReadModel }
+      factory = subject.new(read_model_class)
+      assert_instance_of MR::Factory::ReadModelFactory, factory
+    end
+
+  end
+
+end

data/test/system/read_model_tests.rb

@@ -0,0 +1,199 @@
+require 'assert'
+require 'mr/read_model'
+
+require 'mr/factory'
+require 'test/support/setup_test_db'
+require 'test/support/factory/area'
+require 'test/support/factory/comment'
+require 'test/support/factory/image'
+require 'test/support/factory/user'
+require 'test/support/read_models/comment_with_user_data'
+require 'test/support/read_models/subquery_data'
+require 'test/support/read_models/set_data'
+require 'test/support/read_models/user_with_area_data'
+
+module MR::ReadModel
+
+  class SystemTests < DbTests
+    desc "MR::ReadModel"
+
+  end
+
+  class FieldsSystemTests < SystemTests
+    desc "fields"
+    setup do
+      @area    = Factory::Area.saved_instance
+      @user    = Factory::User.saved_instance(:area => @area)
+      @image   = Factory::Image.saved_instance(:user => @user)
+      @comment = Factory::Comment.saved_instance(:parent => @user)
+      @comment_with_user_data = CommentWithUserData.query.results.first
+    end
+    subject{ @comment_with_user_data }
+
+    should have_readers :comment_id, :comment_created_at
+    should have_readers :user_name, :user_number, :user_salary, :user_started_on
+    should have_readers :area_active, :area_meeting_time
+
+    should "know it's different model's data" do
+      # reload the comment/area -- force AR to type-cast it's columns, otherwise
+      # comment has whatever fake data it was given, which may not match up
+      # like Time != DateTime
+      @comment = Comment.find(@comment.id)
+      @image   = Image.find(@image.id)
+      @user    = User.find(@user.id)
+      @area    = Area.find(@area.id)
+      assert_equal @comment.id,         subject.comment_id
+      assert_equal @comment.created_at, subject.comment_created_at
+      assert_equal @user.name,          subject.user_name
+      assert_equal @user.number,        subject.user_number
+      assert_equal @user.salary,        subject.user_salary
+      assert_equal @user.started_on,    subject.user_started_on
+      assert_equal @user.dob,           subject.user_dob
+      assert_equal @image.data,         subject.image_data
+      assert_equal @area.active,        subject.area_active
+      assert_equal @area.meeting_time,  subject.area_meeting_time
+      assert_equal @area.description,   subject.area_description
+      assert_equal @area.percentage,    subject.area_percentage
+    end
+
+  end
+
+  class QuerySystemTests < SystemTests
+    desc "query"
+    setup do
+      @matching_user = Factory::User.instance_stack.tap(&:create).model
+      @not_matching_user = Factory::User.instance_stack.tap(&:create).model
+      @query = UserWithAreaData.query(@matching_user.area_id)
+    end
+    subject{ @query }
+
+    should "return an MR::Query" do
+      assert_instance_of MR::Query, subject
+    end
+
+    should "filter records based on the user's area" do
+      results = subject.results
+      assert_equal 1, results.size
+      assert_equal @matching_user.id,      results.first.user_id
+      assert_equal @matching_user.area_id, results.first.area_id
+    end
+
+  end
+
+  class FindSystemTests < SystemTests
+    desc "find"
+    setup do
+      @matching_user = Factory::User.instance_stack.tap(&:create).model
+      @user_with_area_data = UserWithAreaData.find(@matching_user.id)
+    end
+    subject{ @user_with_area_data }
+
+    should "find a specific record by it's id" do
+      assert_kind_of UserWithAreaData, subject
+      assert_equal @matching_user.id, subject.user_id
+    end
+
+  end
+
+  class SubquerySetupTests < SystemTests
+    setup do
+      @user = Factory::User.saved_model({
+        :area => { :active => true }
+      })
+      @area       = @user.area
+      @started_on = @user.started_on
+      @comment = Factory::Comment.saved_instance(:parent => @user)
+    end
+
+  end
+
+  class SubquerySystemTests < SubquerySetupTests
+    desc "query that uses subqueries"
+    setup do
+      @results = SubqueryData.query(:started_on => @started_on).results
+    end
+    subject{ @results }
+
+    should "have found the matching area, user and comment data" do
+      assert_equal 1, subject.size
+      assert_includes @area.id,    subject.map(&:area_id)
+      assert_includes @user.id,    subject.map(&:user_id)
+      assert_includes @comment.id, subject.map(&:comment_id)
+    end
+
+  end
+
+  class SubqueryFindSystemTests < SubquerySetupTests
+    desc "find that uses subqueries"
+    setup do
+      @result = SubqueryData.find(@area.id, :started_on => @started_on)
+    end
+    subject{ @result }
+
+    should "have found the matching area, user and comment data" do
+      assert_equal @area.id,    subject.area_id
+      assert_equal @user.id,    subject.user_id
+      assert_equal @comment.id, subject.comment_id
+    end
+
+  end
+
+  class SetOperatorSetupTests < SystemTests
+    setup do
+      @params = {
+        :match_start       => Factory.string,
+        :other_match_start => Factory.string,
+        :match_end         => Factory.string,
+        :non_match         => Factory.string
+      }
+
+      @match_area = Factory::Area.saved_model({
+        :name => "#{@params[:match_start]}_#{Factory.string}_#{@params[:match_end]}"
+      })
+      @other_match_area  = Factory::Area.saved_model({
+        :name => "#{@params[:match_start]}_#{Factory.string}_#{@params[:match_end]}"
+      })
+      @only_match_start_area = Factory::Area.saved_model({
+        :name => "#{@params[:match_start]}_#{Factory.string}"
+      })
+      @only_other_match_start_area = Factory::Area.saved_model({
+        :name => "#{@params[:other_match_start]}_#{Factory.string}"
+      })
+      @only_match_end_area = Factory::Area.saved_model({
+        :name => "#{Factory.string}_#{@params[:match_end]}"
+      })
+      @non_match_area = Factory::Area.saved_model({
+        :name => "#{@params[:match_start]}_#{@params[:non_match]}_#{@params[:match_end]}"
+      })
+    end
+
+  end
+
+  class SetOperatorSystemTests < SetOperatorSetupTests
+    desc "query that uses set operators"
+    setup do
+      @results = SetData.query(@params).results
+    end
+    subject{ @results }
+
+    should "have found the matching area data" do
+      exp = [@match_area, @other_match_area].map(&:id)
+      assert_equal exp, subject.map(&:id)
+    end
+
+  end
+
+  class SetOperatorFindSystemTests < SetOperatorSetupTests
+    desc "find that uses set operators"
+    setup do
+      @result = SetData.find(@other_match_area.id, @params)
+    end
+    subject{ @result }
+
+    should "have found the matching area, user and comment data" do
+      assert_equal @other_match_area.id, subject.id
+    end
+
+  end
+
+end

data/test/system/with_model_tests.rb

@@ -0,0 +1,275 @@
+require 'assert'
+require 'mr'
+
+require 'test/support/setup_test_db'
+require 'test/support/factory/area'
+require 'test/support/factory/user'
+require 'test/support/models/area'
+require 'test/support/models/comment'
+require 'test/support/models/user'
+
+class WithModelTests < DbTests
+  desc "MR with an ActiveRecord model"
+  setup do
+    @area = Factory::Area.instance_stack.tap(&:create).model
+    @user = User.new(:name => "Joe Test", :area => @area)
+  end
+  subject{ @user }
+
+  should "allow accessing the record's attributes" do
+    assert_nothing_raised do
+      subject.name   = 'Joe Test'
+      subject.number = 12345
+    end
+
+    # check that the attributes were set
+    assert_equal 'Joe Test', subject.record.name
+    assert_equal 12345,      subject.record.number
+
+    # check that we can read the attributes
+    assert_equal 'Joe Test', subject.name
+    assert_equal 12345,      subject.number
+  end
+
+  should "allow reading previous values for a record's attribute" do
+    assert_nil subject.name_was
+    subject.name = 'Test'
+    assert_nil subject.name_was
+    subject.save
+    assert_equal 'Test', subject.name_was
+    subject.name = 'New Test'
+    assert_equal 'Test', subject.name_was
+  end
+
+  should "allow mass setting and reading the record's attributes" do
+    assert_nothing_raised do
+      subject.fields = {
+        :name   => 'Joe Test',
+        :number => 12345,
+      }
+    end
+
+    # check that the attributes were set
+    assert_equal 'Joe Test', subject.record.name
+    assert_equal 12345,      subject.record.number
+
+    expected = {
+      'id'         => nil,
+      'name'       => 'Joe Test',
+      'number'     => 12345,
+      'salary'     => nil,
+      'started_on' => nil,
+      'dob'        => nil,
+      'area_id'    => @area.id,
+    }
+    assert_equal expected, subject.fields
+  end
+
+  should "be able to save and destroy the model" do
+    assert_nothing_raised do
+      subject.fields = {
+        :name   => 'Joe Test',
+        :number => 12345,
+      }
+      subject.save
+    end
+    assert_not subject.destroyed?
+    assert UserRecord.exists?(subject.id)
+
+    assert_nothing_raised do
+      subject.destroy
+    end
+    assert subject.destroyed?
+    assert_not UserRecord.exists?(subject.id)
+  end
+
+end
+
+class DetectChangedFieldsTests < WithModelTests
+  setup do
+    @user = User.new(:area => @area)
+  end
+
+  should "detect when it's fields have changed" do
+    assert subject.new?
+    assert_not subject.name_changed?
+    subject.name = 'Test'
+    assert subject.name_changed?
+
+    subject.save
+    assert_not subject.new?
+    assert_not subject.name_changed?
+    subject.name = 'New Test'
+    assert subject.name_changed?
+  end
+
+end
+
+class BelongsToTests < WithModelTests
+  desc "using a belongs to association"
+  setup do
+    @user.area = nil
+    @area = Area.new(:name => 'Alpha').tap(&:save)
+  end
+
+  should "be able to read it and write to it" do
+    assert_nil subject.area
+    assert_nothing_raised do
+      subject.area = @area
+    end
+    assert_equal @area,    subject.area
+    assert_equal @area.id, subject.area_id
+  end
+
+end
+
+class HasManyTests < WithModelTests
+  desc "using a has many association"
+  setup do
+    @user.save
+    @comment = Comment.new(:body => "Test", :parent => @user)
+  end
+
+  should "be able to read it" do
+    @comment.save
+    assert_equal [ @comment ], subject.comments
+  end
+
+end
+
+class HasOneTests < WithModelTests
+  desc "using a has one association"
+  setup do
+    @user.save
+    @image = Image.new(:file_path => "test", :user => @user)
+  end
+
+  should "be able to read it" do
+    @image.save
+    assert_equal @image, subject.image
+  end
+
+end
+
+class PolymorphicBelongsToTests < WithModelTests
+  desc "using a polymorphic belongs to association"
+  setup do
+    @user.save
+    @area = Area.new(:name => 'Alpha')
+    @area.save
+    @comment = Comment.new(:body => "Test")
+  end
+  subject{ @comment }
+
+  should "be able to read it and write to it" do
+    assert_nil subject.parent
+
+    assert_nothing_raised do
+      subject.parent = @area
+    end
+    assert_equal @area,        subject.parent
+    assert_equal @area.id,     subject.parent_id
+    assert_equal 'AreaRecord', subject.parent_type
+
+    assert_nothing_raised do
+      subject.parent = @user
+    end
+    assert_equal @user,        subject.parent
+    assert_equal @user.id,     subject.parent_id
+    assert_equal 'UserRecord', subject.parent_type
+  end
+
+end
+
+class QueryTests < WithModelTests
+  desc "using a MR::Query"
+  setup do
+    @users = [*(0..4)].map do |i|
+      User.new(:name => "test #{i}", :area => @area).tap(&:save)
+    end
+    @query = MR::Query.new(User, UserRecord.scoped)
+  end
+  subject{ @query }
+
+  should "fetch the results with #results" do
+    assert_equal @users.map(&:name), subject.results.map(&:name)
+  end
+
+  should "count the results with #count" do
+    assert_equal 5, subject.count
+  end
+
+end
+
+class PagedQueryTests < QueryTests
+  setup do
+    @paged_query = @query.paged(1, 3)
+  end
+  subject{ @paged_query }
+
+  should "fetch the paged results with #results" do
+    assert_equal @users[0, 3], subject.results
+
+    paged_query = @query.paged(2, 3)
+    assert_equal @users[3, 2], paged_query.results
+  end
+
+  should "count the paged results with #count" do
+    assert_equal 3, subject.count
+
+    paged_query = @query.paged(2, 3)
+    assert_equal 2, paged_query.count
+  end
+
+  should "count the total number of results with #total_count" do
+    assert_equal 5, subject.total_count
+  end
+
+end
+
+class FinderTests < WithModelTests
+  setup do
+    @users = [*1..2].map do |i|
+      Factory::User.instance(:area => @area).tap(&:save)
+    end
+  end
+
+  should "allow fetching a single user with find" do
+    assert_equal @users.first, User.find(@users.first.id)
+
+    assert_raises(ActiveRecord::RecordNotFound) do
+      User.find(1000)
+    end
+  end
+
+  should "allow fetching a all users with all" do
+    assert_equal @users, User.all
+  end
+
+end
+
+class InvalidTests < WithModelTests
+  desc "when saving an invalid model"
+  setup do
+    @area = Area.new(ValidAreaRecord.new)
+  end
+  subject{ @area }
+
+  should "raise a InvalidModel exception with the ActiveRecord error messages" do
+    exception = nil
+    begin
+      subject.save
+    rescue Exception => exception
+    end
+
+    assert_instance_of MR::Model::InvalidError, exception
+    assert_equal [ "can't be blank" ], exception.errors[:name]
+    assert_includes ":name can't be blank", exception.message
+  end
+
+  should "return the ActiveRecord's error messages with errors" do
+    subject.valid?
+    assert_equal [ "can't be blank" ], subject.errors[:name]
+  end
+
+end