bbrowning-virtualbox 0.7.6.dev

data/test/virtualbox/abstract_model/relatable_test.rb

@@ -0,0 +1,348 @@
+require File.expand_path("../../../test_helper", __FILE__)
+
+class RelatableTest < Test::Unit::TestCase
+  class Relatee
+    def self.populate_relationship(caller, data)
+      "FOO"
+    end
+  end
+
+  class BarRelatee
+    def self.set_relationship(caller, old_value, new_value)
+    end
+  end
+
+  class EmptyRelatableModel
+    include VirtualBox::AbstractModel::Relatable
+  end
+
+  class RelatableModel < EmptyRelatableModel
+    relationship :foos, RelatableTest::Relatee
+    relationship :bars, RelatableTest::BarRelatee
+  end
+
+  setup do
+    @data = {}
+  end
+
+  context "class methods" do
+    should "read back relationships in order added" do
+      order = mock("order")
+      order_seq = sequence("order_seq")
+      order.expects(:foos).in_sequence(order_seq)
+      order.expects(:bars).in_sequence(order_seq)
+
+      RelatableModel.relationships.each do |name, options|
+        order.send(name)
+      end
+    end
+  end
+
+  context "setting a relationship" do
+    setup do
+      @model = RelatableModel.new
+    end
+
+    should "have a magic method relationship= which calls set_relationship" do
+      @model.expects(:set_relationship).with(:foos, "FOOS!")
+      @model.foos = "FOOS!"
+    end
+
+    should "raise a NonSettableRelationshipException if relationship can't be set" do
+      assert_raises(VirtualBox::Exceptions::NonSettableRelationshipException) {
+        @model.foos = "FOOS!"
+      }
+    end
+
+    should "call set_relationship on the relationship class" do
+      BarRelatee.expects(:populate_relationship).returns("foo")
+      @model.populate_relationships({})
+
+      BarRelatee.expects(:set_relationship).with(@model, "foo", "bars")
+      assert_nothing_raised { @model.bars = "bars" }
+    end
+
+    should "set the result of set_relationship as the new relationship data" do
+      BarRelatee.stubs(:set_relationship).returns("hello")
+      @model.bars = "zoo"
+      assert_equal "hello", @model.bars
+    end
+  end
+
+  context "subclasses" do
+    class SubRelatableModel < RelatableModel
+      relationship :bars, RelatableTest::Relatee
+    end
+
+    setup do
+      @relationships = SubRelatableModel.relationships
+    end
+
+    should "inherit relationships of parent" do
+      assert SubRelatableModel.has_relationship?(:foos)
+      assert SubRelatableModel.has_relationship?(:bars)
+    end
+
+    should "inherit options of relationships" do
+      assert_equal Relatee, SubRelatableModel.relationships_hash[:foos][:klass]
+    end
+  end
+
+  context "default callbacks" do
+    setup do
+      @model = RelatableModel.new
+    end
+
+    should "not raise an error if populate_relationship doesn't exist" do
+      assert !BarRelatee.respond_to?(:populate_relationship)
+      assert_nothing_raised { @model.populate_relationships(nil) }
+    end
+
+    should "not raise an error when saving relationships if the callback doesn't exist" do
+      assert !Relatee.respond_to?(:save_relationship)
+      assert_nothing_raised { @model.save_relationships }
+    end
+
+    should "not raise an error in destroying relationships if the callback doesn't exist" do
+      assert !Relatee.respond_to?(:destroy_relationship)
+      assert_nothing_raised { @model.destroy_relationships }
+    end
+  end
+
+  context "destroying" do
+    setup do
+      @model = RelatableModel.new
+      @model.populate_relationships({})
+    end
+
+    context "a single relationship" do
+      should "call destroy_relationship only for the given relationship" do
+        Relatee.expects(:destroy_relationship).once
+        BarRelatee.expects(:destroy_relationship).never
+        @model.destroy_relationship(:foos)
+      end
+
+      should "forward any args passed into destroy_relationship" do
+        Relatee.expects(:destroy_relationship).with(@model, anything, "HELLO").once
+        @model.destroy_relationship(:foos, "HELLO")
+      end
+
+      should "pass the data into destroy_relationship" do
+        Relatee.expects(:destroy_relationship).with(@model, "FOO").once
+        @model.destroy_relationship(:foos)
+      end
+
+      should "call read_relationship (to force the load if lazy)" do
+        Relatee.expects(:destroy_relationship).with(@model, "FOO").once
+        @model.expects(:read_relationship).with(:foos).once
+        @model.destroy_relationship(:foos)
+      end
+    end
+
+    context "all relationships" do
+      should "call destroy_relationship on the related class" do
+        Relatee.expects(:destroy_relationship).with(@model, anything).once
+        @model.destroy_relationships
+      end
+
+      should "forward any args passed into destroy relationships" do
+        Relatee.expects(:destroy_relationship).with(@model, anything, "HELLO").once
+        @model.destroy_relationships("HELLO")
+      end
+    end
+  end
+
+  context "lazy relationships" do
+    class LazyRelatableModel < EmptyRelatableModel
+      relationship :foos, RelatableTest::Relatee, :lazy => true
+      relationship :bars, RelatableTest::BarRelatee
+    end
+
+    setup do
+      @model = LazyRelatableModel.new
+    end
+
+    should "return true if a relationship is lazy, and false if not, when checking" do
+      assert @model.lazy_relationship?(:foos)
+      assert !@model.lazy_relationship?(:bars)
+    end
+
+    should "not be loaded by default" do
+      assert !@model.loaded_relationship?(:foos)
+    end
+
+    should "call `load_relationship` on initial load" do
+      @model.expects(:load_relationship).with(:foos).once
+      @model.foos
+    end
+
+    should "not call `load_relationship` for non lazy attributes" do
+      @model.expects(:load_relationship).never
+      @model.bars
+    end
+
+    should "mark a relationship as loaded on populate_relationship" do
+      @model.populate_relationship(:foos, {})
+      assert @model.loaded_relationship?(:foos)
+    end
+
+    should "not populate the lazy relationship right away" do
+      Relatee.expects(:populate_relationship).never
+      BarRelatee.expects(:populate_relationship).once
+      @model.populate_relationships({})
+    end
+  end
+
+  context "saving relationships" do
+    class RelatableWithLazyModel < RelatableModel
+      relationship :bazs, RelatableTest::Relatee, :lazy => true
+      relationship :vers, RelatableTest::Relatee, :version => "3.1"
+
+      def load_relationship(name)
+        populate_relationship(:bazs, "foo")
+      end
+    end
+
+    setup do
+      @model = RelatableWithLazyModel.new
+      VirtualBox.stubs(:version).returns("3.1.3")
+    end
+
+    should "call save_relationship for all relationships" do
+      @model.expects(:save_relationship).with(:foos).returns(true)
+      @model.expects(:save_relationship).with(:bars).returns(true)
+      @model.expects(:save_relationship).with(:bazs).returns(true)
+      @model.expects(:save_relationship).with(:vers).returns(true)
+      assert @model.save_relationships
+    end
+
+    should "not call save_relationship on non-loaded relations" do
+      Relatee.expects(:save_relationship).never
+      @model.save_relationship(:bazs)
+    end
+
+    should "not call save_relationship on relationships with mismatched versions" do
+      VirtualBox.stubs(:version).returns("3.2.4")
+      Relatee.expects(:save_relationship).never
+      @model.save_relationship(:vers)
+    end
+
+    should "call save_relationship on loaded lazy relationships" do
+      @model.load_relationship(:bazs)
+      Relatee.expects(:save_relationship).once
+      @model.save_relationship(:bazs)
+    end
+
+    should "call save_relationship on the related class" do
+      Relatee.expects(:save_relationship).with(@model, @model.foos).once.returns(:r)
+      assert_equal :r, @model.save_relationship(:foos)
+    end
+
+    should "forward parameters through" do
+      Relatee.expects(:save_relationship).with(@model, @model.foos, "YES").once
+      @model.save_relationship(:foos, "YES")
+    end
+  end
+
+  context "reading relationships" do
+    class VersionedRelatableModel < RelatableModel
+      relationship :ver, :Ver, :version => "3.1"
+    end
+
+    setup do
+      @model = VersionedRelatableModel.new
+    end
+
+    should "provide a read method for relationships" do
+      assert_nothing_raised { @model.foos }
+    end
+
+    should "raise an exception if invalid version for versioned relationships" do
+      VirtualBox.stubs(:version).returns("3.0.14")
+      assert_raises(VirtualBox::Exceptions::UnsupportedVersionException) {
+        @model.ver
+      }
+    end
+
+    should "not raise an exception if valid version for versioned relationship" do
+      VirtualBox.stubs(:version).returns("3.1.8")
+      assert_nothing_raised {
+        @model.ver
+      }
+    end
+  end
+
+  context "checking for relationships" do
+    setup do
+      @model = RelatableModel.new
+    end
+
+    should "have a class method as well" do
+      assert RelatableModel.has_relationship?(:foos)
+      assert !RelatableModel.has_relationship?(:bazs)
+    end
+
+    should "return true for existing relationships" do
+      assert @model.has_relationship?(:foos)
+    end
+
+    should "return false for nonexistent relationships" do
+      assert !@model.has_relationship?(:bazs)
+    end
+  end
+
+  context "determining the class of relationships" do
+    class ClassRelatableModel < EmptyRelatableModel
+      relationship :foo, RelatableTest::Relatee
+      relationship :bar, "RelatableTest::BarRelatee"
+    end
+
+    setup do
+      @model = ClassRelatableModel.new
+    end
+
+    should "just return the class for Class types" do
+      assert_equal Relatee, @model.relationship_class(:foo)
+    end
+
+    should "turn string into class" do
+      assert_equal BarRelatee, @model.relationship_class(:bar)
+    end
+  end
+
+  context "populating relationships" do
+    class PopulatingRelatableModel < RelatableModel
+      relationship :bazs, RelatableTest::Relatee, :version => "3.1"
+    end
+
+    setup do
+      @model = PopulatingRelatableModel.new
+      VirtualBox.stubs(:version).returns("3.1.4")
+    end
+
+    should "be able to populate a single relationship" do
+      Relatee.expects(:populate_relationship).with(@model, @data).once
+      @model.populate_relationship(:foos, @data)
+    end
+
+    should "not populate versioned relationships if version mismatch" do
+      VirtualBox.stubs(:version).returns("3.0.4")
+      Relatee.expects(:populate_relationship).never
+      @model.populate_relationship(:bazs, @data)
+    end
+
+    should "call populate_relationship on the related class" do
+      populate_seq = sequence("populate_seq")
+      @model.expects(:populate_relationship).with(:foos, @data).once.in_sequence(populate_seq)
+      @model.expects(:populate_relationship).with(:bars, @data).once.in_sequence(populate_seq)
+      @model.expects(:populate_relationship).with(:bazs, @data).once.in_sequence(populate_seq)
+      @model.populate_relationships(@data)
+    end
+
+    should "properly save returned value as the value for the relationship" do
+      Relatee.expects(:populate_relationship).twice.returns("HEY")
+      @model.populate_relationships(@data)
+      assert_equal "HEY", @model.foos
+    end
+  end
+end

data/test/virtualbox/abstract_model/validatable_test.rb

@@ -0,0 +1,308 @@
+require File.expand_path("../../../test_helper", __FILE__)
+
+class ValidatableTest < Test::Unit::TestCase
+  class ValidatableModel
+    include VirtualBox::AbstractModel::Validatable
+
+    attr_accessor :foos
+    attr_accessor :bars
+  end
+
+  context "errors" do
+    setup do
+      @model = ValidatableModel.new
+    end
+
+    should "have no errors by default" do
+      assert @model.errors.empty?
+    end
+
+    should "be able to add errors" do
+      @model.add_error(:foo, "is blank")
+      assert !@model.errors.empty?
+      assert !@model.errors[:foo].nil?
+      assert_equal "is blank", @model.errors[:foo].first
+    end
+
+    should "be able to add multiple errors" do
+      @model.add_error(:foo, "foo")
+      @model.add_error(:foo, "bar")
+      assert !@model.errors.empty?
+      assert !@model.errors[:foo].nil?
+      assert_equal 2, @model.errors[:foo].length
+    end
+
+    should "be able to clear errors" do
+      @model.add_error(:foo, "foo")
+      assert !@model.errors.empty?
+      @model.clear_errors
+      assert @model.errors.empty?
+    end
+
+    should "be able to get full error messages" do
+      @model.add_error(:foo, "should be bar.")
+      assert_equal ['Foo should be bar.'], @model.full_error_messages
+    end
+
+    should "be able to get the errors on a specific field" do
+      @model.add_error(:foo, "an error.")
+      assert @model.errors_on(:bar).nil?
+      assert @model.errors_on(:foo)
+    end
+  end
+
+  context "validity" do
+    setup do
+      @model = ValidatableModel.new
+    end
+
+    should "call validate on valid?" do
+      @model.expects(:validate)
+      assert @model.valid?
+    end
+
+    should "be valid if there are no errors" do
+      assert @model.valid?
+    end
+
+    should "be invalid if there are any errors" do
+      @model.add_error(:foo, "foo")
+      assert !@model.valid?
+    end
+
+    should "have a validate method by default which returns true" do
+      assert @model.validate
+    end
+  end
+
+  context "extracting options hash from multi-param functions" do
+    setup do
+      @model = ValidatableModel.new
+    end
+
+    should "modify the initial fields array" do
+      fields = [{}]
+      @model.__validates_extract_options(fields, {})
+      assert fields.empty?
+    end
+
+    should "not modify the initial fields array if not a hash at the end" do
+      fields = [:foo]
+      @model.__validates_extract_options(fields, {})
+      assert_equal [:foo], fields
+    end
+
+    should "return the defaults hash merged with the given options" do
+      fields = [{ :foo => :bar }]
+      result = @model.__validates_extract_options(fields, { :foo => 0, :bar => :baz })
+      assert_equal({ :foo => :bar, :bar => :baz }, result)
+    end
+  end
+
+  context "specific validations" do
+    setup do
+      @model = ValidatableModel.new
+    end
+
+    context "validates_presence_of" do
+      setup do
+        @model.foos = "foo"
+        @model.bars = "bar"
+      end
+
+      should "not add an error if not blank" do
+        @model.validates_presence_of(:foos)
+        assert @model.valid?
+      end
+
+      should "add an error if blank field" do
+        @model.foos = ""
+        @model.validates_presence_of(:foos)
+        assert !@model.valid?
+      end
+
+      should "add an error for a nil field" do
+        @model.foos = nil
+        @model.validates_presence_of(:foos)
+        assert !@model.valid?
+      end
+
+      should "validate multiple fields" do
+        @model.bars = nil
+        @model.validates_presence_of(:foos, :bars)
+
+        assert !@model.valid?
+        assert @model.errors[:bars]
+      end
+
+      should "return false on invalid" do
+        @model.bars =  nil
+        assert !@model.validates_presence_of(:bars)
+      end
+
+      should "return true on valid" do
+        @model.bars = "foo"
+        assert @model.validates_presence_of(:bars)
+      end
+
+      should "return false if any are invalid on multiple fields" do
+        @model.bars = nil
+        assert !@model.validates_presence_of(:foos, :bars)
+      end
+
+      should "return true if all fields are valid" do
+        @model.foos = "foo"
+        @model.bars = "bar"
+        assert @model.validates_presence_of(:foos, :bars)
+      end
+
+      should "add error message if invalid" do
+        @model.foos = nil
+        assert !@model.validates_presence_of(:foos)
+        assert_equal "can't be blank.", @model.errors[:foos].first
+      end
+
+      should "use custom error message if given" do
+        @model.foos = nil
+        assert !@model.validates_presence_of(:foos, :message => "can't be nil.")
+        assert_equal "can't be nil.", @model.errors[:foos].first
+      end
+    end
+
+    context "validates_format_of" do
+      setup do
+        @model.foos = "foo"
+        @model.bars = "bar"
+      end
+
+      should "not add an error if formatted properly" do
+        @model.validates_format_of(:foos, :with => /^foo$/)
+        assert @model.valid?
+      end
+
+      should "add an error if not formatted properly" do
+        @model.validates_format_of(:bars, :with => /^foo$/)
+        assert !@model.valid?
+      end
+
+      should "not add an error for a nil field" do
+        @model.foos = nil
+        @model.validates_format_of(:foos, :with => /^foo$/)
+        assert @model.valid?
+      end
+
+      should "validate multiple fields" do
+        @model.validates_format_of(:foos, :bars, :with => /^foo$/)
+        assert !@model.valid?
+        assert @model.errors[:bars]
+      end
+
+      should "return false on invalid" do
+        assert !@model.validates_format_of(:bars, :with => /^foo$/)
+      end
+
+      should "return true on valid" do
+        assert @model.validates_format_of(:foos, :with => /^foo$/)
+      end
+
+      should "return false if any are invalid on multiple fields" do
+        assert !@model.validates_format_of(:foos, :bars, :with => /^foo$/)
+      end
+
+      should "return true if all fields are valid" do
+        assert @model.validates_format_of(:foos, :bars, :with => /^\w+$/)
+      end
+    end
+
+    context "validates_numericality_of" do
+      setup do
+        @model.foos = 1
+        @model.bars = "1"
+      end
+
+      should "not add an error if a number" do
+        @model.validates_numericality_of(:foos)
+        assert @model.valid?
+      end
+
+      should "add an error if not a number" do
+        @model.validates_numericality_of(:bars)
+        assert !@model.valid?
+      end
+
+      should "not add an error for a nil field" do
+        @model.foos = nil
+        @model.validates_numericality_of(:foos)
+        assert @model.valid?
+      end
+
+      should "validate multiple fields" do
+        @model.validates_numericality_of(:foos, :bars)
+        assert !@model.valid?
+        assert @model.errors[:bars]
+      end
+
+      should "return false on invalid" do
+        assert !@model.validates_numericality_of(:bars)
+      end
+
+      should "return true on valid" do
+        assert @model.validates_numericality_of(:foos)
+      end
+
+      should "return false if any are invalid on multiple fields" do
+        assert !@model.validates_numericality_of(:foos, :bars)
+      end
+
+      should "return true if all fields are valid" do
+        @model.bars = 2
+        assert @model.validates_numericality_of(:foos, :bars)
+      end
+    end
+
+    context "validates_inclusion_of" do
+      setup do
+        @model.foos = 1
+        @model.bars = 2
+      end
+
+      should "not add an error if value is included" do
+        @model.validates_inclusion_of(:foos, :in => [1])
+        assert @model.valid?
+      end
+
+      should "add an error if value is not included" do
+        @model.validates_inclusion_of(:bars, :in => [1])
+        assert !@model.valid?
+      end
+
+      should "not add an error for a nil field" do
+        @model.foos = nil
+        @model.validates_inclusion_of(:foos, :in => [1,2])
+        assert @model.valid?
+      end
+
+      should "validate multiple fields" do
+        @model.validates_inclusion_of(:foos, :bars, :in => [1,3])
+        assert !@model.valid?
+        assert @model.errors[:bars]
+      end
+
+      should "return false on invalid" do
+        assert !@model.validates_inclusion_of(:bars, :in => [1])
+      end
+
+      should "return true on valid" do
+        assert @model.validates_inclusion_of(:foos, :in => [1])
+      end
+
+      should "return false if any are invalid on multiple fields" do
+        assert !@model.validates_inclusion_of(:foos, :bars, :in => [1,3])
+      end
+
+      should "return true if all fields are valid" do
+        assert @model.validates_inclusion_of(:foos, :bars, :in => [1,2])
+      end
+    end
+  end
+end