mr 0.35.2

data/test/unit/record_tests.rb

@@ -0,0 +1,45 @@
+require 'assert'
+require 'mr/record'
+
+require 'much-plugin'
+
+module MR::Record
+
+  class UnitTests < Assert::Context
+    desc "MR::Record"
+    setup do
+      @record_class = Class.new do
+        include MR::Record
+        self.model_class = FakeTestModel
+      end
+    end
+    subject{ @record_class }
+
+    should have_accessors :model_class
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, MR::Record
+    end
+
+  end
+
+  class InstanceTests < UnitTests
+    desc "instance"
+    setup do
+      @record = @record_class.new
+    end
+    subject{ @record }
+
+    should have_accessors :model
+
+    should "build a model if one hasn't been set" do
+      assert_instance_of FakeTestModel, subject.model
+    end
+
+  end
+
+  class FakeTestModel
+    include MR::Model
+  end
+
+end

data/test/unit/test_helpers_tests.rb

@@ -0,0 +1,431 @@
+require 'assert'
+require 'mr/test_helpers'
+
+require 'mr/factory'
+require 'mr/model'
+
+module MR::TestHelpers
+
+  class UnitTests < Assert::Context
+    desc "MR::TestHelpers"
+    subject{ MR::TestHelpers }
+
+    should have_imeths :model_reset_save_called
+    should have_imeths :assert_association_saved, :assert_not_association_saved
+    should have_imeths :assert_model_destroyed, :assert_not_model_destroyed
+    should have_imeths :assert_model_saved, :assert_not_model_saved
+    should have_imeths :assert_field_saved, :assert_not_field_saved
+
+  end
+
+  class WithModelTests < UnitTests
+    setup do
+      @associated_record = FakeTestRecord.new
+      @associated_model = FakeTestModel.new(@associated_record).tap(&:save)
+      @model = FakeTestModel.new({
+        :name   => 'Test',
+        :area   => @associated_model,
+        :parent => @associated_model
+      })
+    end
+  end
+
+  class TestingActualModelTests < WithModelTests
+    include MR::TestHelpers
+
+    desc "with an actual model"
+    subject{ @model }
+
+    should "be able to test if an association was saved or not" do
+      assert_not_model_saved subject
+      assert_not_association_saved subject, :parent, @associated_model
+      @model.save
+      assert_model_saved subject
+      assert_association_saved subject, :parent, @associated_model
+      @other_model = FakeTestModel.new.tap(&:save)
+      @model.parent = @other_model
+      @model.save
+      assert_association_saved subject, :parent, @other_model
+    end
+
+    should "be able to test if an polymorphic association was saved when " \
+           "the model `record_class` doesn't match it's actual record's class" do
+      associated_record = OtherFakeTestRecord.new
+      associated_model  = FakeTestModel.new(associated_record).tap(&:save)
+      @model.parent = associated_model
+      @model.save
+      assert_model_saved subject
+      assert_association_saved subject, :parent, associated_model
+    end
+
+    should "be able to test if a field was saved or not" do
+      assert_not_model_saved subject
+      assert_not_field_saved subject, :name, 'Test'
+      @model.save
+      assert_model_saved subject
+      assert_field_saved subject, :name, 'Test'
+      @model.name = 'Joe'
+      @model.save
+      assert_field_saved subject, :name, 'Joe'
+    end
+
+    should "be able to test if a model was destroyed or not" do
+      assert_not_model_destroyed subject
+      @model.save
+      assert_not_model_destroyed subject
+      @model.destroy
+      assert_model_destroyed subject
+    end
+
+    should "reset a fake model's `save_called` state using `model_reset_save_called`" do
+      @model.save
+      model_reset_save_called @model
+      assert_not_model_saved @model
+    end
+
+    should "yield the model passed to it before resetting using `model_reset_save_called`" do
+      yielded = nil
+      model_reset_save_called(@model) do |m|
+        yielded = m
+        m.save
+      end
+      assert_equal @model, yielded
+      assert_not_model_saved @model
+    end
+
+    should "raise an ArgumentError when passed a model not using a fake record" do
+      record_class = Class.new{ include MR::Record }
+      model = FakeTestModel.new(record_class.new)
+      assert_raises(ArgumentError){ model_reset_save_called(model) }
+    end
+
+  end
+
+  class WithAssertContextSpyTests < WithModelTests
+    setup do
+      @model.save
+      @assert_context_spy = AssertContextSpy.new
+    end
+  end
+
+  class AssociationSavedAssertionBaseTests < WithAssertContextSpyTests
+    desc "AssociationSavedAssertionBase"
+
+    should "raise an ArgumentError when given a non belongs to association" do
+      assert_raises(ArgumentError) do
+        AssociationSavedAssertionBase.new(@model, :comments)
+      end
+    end
+
+  end
+
+  class AssociationSavedAssertionTests < WithAssertContextSpyTests
+    desc "AssociationSavedAssertion"
+    setup do
+      @assertion = AssociationSavedAssertion.new(
+        @model,
+        :area,
+        @associated_model
+      )
+    end
+    subject{ @assertion }
+
+    should have_imeths :run
+
+    should "assert that the association's foreign key was saved as " \
+           "the expected value when run" do
+      subject.run(@assert_context_spy)
+      assert_equal 1, @assert_context_spy.results.size
+      assert_equal [ true ], @assert_context_spy.results.map(&:value)
+      descriptions = @assert_context_spy.results.map(&:desc)
+      expected = "Expected \"area_id\" field was saved " \
+                 "as #{@associated_model.id}."
+      assert_includes expected, descriptions
+    end
+
+  end
+
+  class AssociationSavedAssertionPolyTests < AssociationSavedAssertionTests
+    desc "run for a polymorphic belongs to"
+    setup do
+      @assertion = AssociationSavedAssertion.new(
+        @model,
+        :parent,
+        @associated_model
+      )
+      @assertion.run(@assert_context_spy)
+    end
+    subject{ @assert_context_spy.results }
+
+    should "have asserted that the association's foreign type and key " \
+           "were saved as the expected value" do
+      assert_equal 2, subject.size
+      assert_equal [ true, true ], subject.map(&:value)
+      descriptions = @assert_context_spy.results.map(&:desc)
+      expected = "Expected \"parent_type\" field was saved " \
+                 "as #{@associated_record.class.name.inspect}."
+      assert_includes expected, descriptions
+      expected = "Expected \"parent_id\" field was saved " \
+                 "as #{@associated_model.id}."
+      assert_includes expected, descriptions
+    end
+
+  end
+
+  class AssociationNotSavedAssertionTests < WithAssertContextSpyTests
+    desc "AssociationNotSavedAssertion"
+    setup do
+      @assertion = AssociationNotSavedAssertion.new(
+        @model,
+        :area,
+        @associated_model
+      )
+    end
+    subject{ @assertion }
+
+    should have_imeths :run
+
+    should "assert that the association's foreign key was not saved " \
+           "as the expected value when run" do
+      subject.run(@assert_context_spy)
+      assert_equal 1, @assert_context_spy.results.size
+      assert_equal [ false ], @assert_context_spy.results.map(&:value)
+      descriptions = @assert_context_spy.results.map(&:desc)
+      expected = "Expected \"area_id\" field was not saved " \
+                 "as #{@associated_model.id}."
+      assert_includes expected, descriptions
+    end
+
+  end
+
+  class AssociationNotSavedAssertionPolyTests < AssociationNotSavedAssertionTests
+    desc "is run for a polymorphic belongs to"
+    setup do
+      @assertion = AssociationNotSavedAssertion.new(
+        @model,
+        :parent,
+        @associated_model
+      )
+      @assertion.run(@assert_context_spy)
+    end
+    subject{ @assert_context_spy.results }
+
+    should "have asserted that the association's foreign type was not saved " \
+           "as the expected value" do
+      assert_equal 2, subject.size
+      assert_equal [ false, false ], subject.map(&:value)
+      descriptions = @assert_context_spy.results.map(&:desc)
+      expected = "Expected \"parent_type\" field was not saved " \
+                 "as #{@associated_record.class.name.inspect}."
+      assert_includes expected, descriptions
+      expected = "Expected \"parent_id\" field was not saved " \
+                 "as #{@associated_model.id}."
+      assert_includes expected, descriptions
+    end
+
+  end
+
+  class FieldSavedAssertionBaseTests < WithAssertContextSpyTests
+    desc "FieldSavedAssertionBase"
+    setup do
+      @assertion = FieldSavedAssertionBase.new(@model, :name, 'Test')
+    end
+    subject{ @assertion }
+
+    should "raise an ArgumentError with a model not using a fake record" do
+      record_class = Class.new{ include MR::Record }
+      model = FakeTestModel.new(record_class.new)
+      assert_raises(ArgumentError){ FieldSavedAssertionBase.new(model, :name) }
+    end
+
+  end
+
+  class FieldSavedAssertionTests < WithAssertContextSpyTests
+    desc "FieldSavedAssertion"
+    setup do
+      @assertion = FieldSavedAssertion.new(@model, :name, 'Test')
+    end
+    subject{ @assertion }
+
+    should have_imeths :run
+
+  end
+
+  class FieldSavedAssertionSavedTests < FieldSavedAssertionTests
+    desc "when run for a field on a saved model"
+    setup do
+      @assertion = FieldSavedAssertion.new(@model, :name, 'Test')
+      @assertion.run(@assert_context_spy)
+      @results = @assert_context_spy.results
+    end
+
+    should "assert that the field was saved as the expected value when run" do
+      assert_equal 1, @results.size
+      assert_equal [ true ], @results.map(&:value)
+      expected = "Expected \"name\" field was saved as \"Test\"."
+      assert_includes expected, @results.map(&:desc)
+    end
+
+  end
+
+  class FieldSavedAssertionUnsavedTests < FieldSavedAssertionTests
+    desc "when run for a field on an unsaved model"
+    setup do
+      # this ensures that this test doesn't pass, a `nil` expected value would
+      # pass if the assertion class only used `assert_equal`
+      @assertion = FieldSavedAssertion.new(FakeTestModel.new, :name, nil)
+      @assertion.run(@assert_context_spy)
+      @results = @assert_context_spy.results
+    end
+
+    should "assert that the field was saved when run" do
+      assert_equal 1, @results.size
+      assert_equal [ false ], @results.map(&:value)
+      expected = "Expected \"name\" field was saved."
+      assert_includes expected, @results.map(&:desc)
+    end
+
+  end
+
+  class FieldNotSavedAssertionTests < WithAssertContextSpyTests
+    desc "FieldNotSavedAssertion"
+    setup do
+      @assertion = FieldNotSavedAssertion.new(@model, :other, 'Test')
+    end
+    subject{ @assertion }
+
+    should have_imeths :run
+
+  end
+
+  class FieldNotSavedAssertionSavedTests < FieldNotSavedAssertionTests
+    desc "when run for a field on a saved model"
+    setup do
+      @assertion = FieldNotSavedAssertion.new(@model, :name, 'Test')
+      @assertion.run(@assert_context_spy)
+      @results = @assert_context_spy.results
+    end
+
+    should "assert that the field was not saved as the expected value when run" do
+      assert_equal 1, @results.size
+      assert_equal [ false ], @results.map(&:value)
+      expected = "Expected \"name\" field was not saved as \"Test\"."
+      assert_includes expected, @results.map(&:desc)
+    end
+
+  end
+
+  class FieldNotSavedAssertionUnsavedTests < FieldNotSavedAssertionTests
+    desc "when run for a field on an unsaved model"
+    setup do
+      # this ensures that this test does pass, a non `nil` expected value would
+      # fail if the assertion class only used `assert_not_equal`
+      @assertion = FieldNotSavedAssertion.new(FakeTestModel.new, :name, 'Test')
+      @assertion.run(@assert_context_spy)
+      @results = @assert_context_spy.results
+    end
+
+    should "assert that the field was not saved when run" do
+      assert_equal 1, @results.size
+      assert_equal [ true ], @results.map(&:value)
+      expected = "Expected \"name\" field was not saved."
+      assert_includes expected, @results.map(&:desc)
+    end
+
+  end
+
+  class ModelDestroyedAssertionTests < WithAssertContextSpyTests
+    desc "ModelDestroyedAssertion"
+    setup do
+      @model.destroy
+      @assertion = ModelDestroyedAssertion.new(@model)
+    end
+    subject{ @assertion }
+
+    should have_imeths :run
+
+    should "assert that the model was destroyed using `run`" do
+      @assertion.run(@assert_context_spy)
+      result = @assert_context_spy.results.last
+      assert_true result.value
+      assert_equal "Expected #{@model.inspect} was destroyed.", result.block.call
+    end
+
+  end
+
+  class ModelNotDestroyedAssertionTests < WithAssertContextSpyTests
+    desc "ModelNotDestroyedAssertion"
+    setup do
+      @assertion = ModelNotDestroyedAssertion.new(@model)
+    end
+    subject{ @assertion }
+
+    should have_imeths :run
+
+    should "assert that the model was not destroyed using `run`" do
+      @assertion.run(@assert_context_spy)
+      result = @assert_context_spy.results.last
+      assert_true result.value
+      assert_equal "Expected #{@model.inspect} was not destroyed.", result.block.call
+    end
+
+  end
+
+  class AssertContextSpy
+    attr_reader :results
+
+    def initialize
+      @results = []
+    end
+
+    def assert_true(actual, desc = nil, &block)
+      self.assert_equal(true, actual, desc, &block)
+    end
+
+    def assert_false(actual, desc = nil, &block)
+      self.assert_equal(false, actual, desc, &block)
+    end
+
+    def assert_equal(expected, actual, desc = nil, &block)
+      self.assert(expected == actual, desc, &block)
+    end
+
+    def assert_not_equal(expected, actual, desc = nil, &block)
+      self.assert(expected != actual, desc)
+    end
+
+    def assert(value, desc = nil, &block)
+      @results << Result.new(value, desc, block)
+    end
+
+    class Result < Struct.new(:value, :desc, :block)
+      def what_failed; (block || proc{ }).call; end
+    end
+  end
+
+  class FakeTestRecord
+    include MR::FakeRecord
+    attribute :name,        :string
+    attribute :active,      :boolean
+    attribute :area_id,     :integer
+    attribute :parent_type, :string
+    attribute :parent_id,   :integer
+    belongs_to :parent, :polymorphic => true
+    belongs_to :area,   :class_name  => self.to_s
+    has_many :comments, :class_name  => self.to_s
+  end
+
+  class OtherFakeTestRecord
+    include MR::FakeRecord
+  end
+
+  class FakeTestModel
+    include MR::Model
+    record_class FakeTestRecord
+    field_accessor :id, :name, :active, :parent_id, :parent_type
+    polymorphic_belongs_to :parent
+    belongs_to :area
+    has_many :comments
+  end
+
+end