velir_virtualbox 0.8.4

data/test/virtualbox/abstract_model/version_matcher_test.rb

@@ -0,0 +1,41 @@
+require File.expand_path("../../../test_helper", __FILE__)
+
+class VersionMatcherTest < Test::Unit::TestCase
+  setup do
+    @module = VirtualBox::AbstractModel::VersionMatcher
+    @klass = Class.new
+    @klass.send(:extend, @module)
+  end
+
+  context "asserting version matches" do
+    should "raise an exception if versions do not match" do
+      assert_raises(VirtualBox::Exceptions::UnsupportedVersionException) {
+        @klass.assert_version_match("3.1", "3.2.4")
+      }
+    end
+
+    should "not raise an exception if versions do match" do
+      assert_nothing_raised {
+        @klass.assert_version_match("3.0", "3.0.14")
+      }
+    end
+  end
+
+  context "version matching" do
+    should "return true if versions match" do
+      assert @klass.version_match?("3.2", "3.2.4")
+      assert !@klass.version_match?("3.1", "3.2.4")
+    end
+  end
+
+  context "splitting version" do
+    should "split into a max of two parts by period" do
+      assert_equal %W[3 2], @klass.split_version("3.2.0")
+      assert_equal %W[3 1], @klass.split_version("3.1.1.1.1")
+    end
+
+    should "return an empty array if it can't split" do
+      assert_equal [], @klass.split_version(nil)
+    end
+  end
+end

data/test/virtualbox/abstract_model_test.rb

@@ -0,0 +1,462 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class AbstractModelTest < Test::Unit::TestCase
+  class Foo
+    def self.set_relationship(caller, old_value, new_value)
+      new_value
+    end
+
+    def self.validate_relationship(caller, data)
+    end
+  end
+
+  class Bar; end
+
+  class FakeModel < VirtualBox::AbstractModel
+    attribute :foo, :property => false
+    attribute :bar
+    relationship :foos, Foo
+    relationship :bars, Bar, :dependent => :destroy
+  end
+
+  context "reloading" do
+    context "with a single class" do
+      setup do
+        @model = FakeModel.new
+      end
+
+      teardown do
+        FakeModel.reloaded!
+      end
+
+      should "not want to be reloaded initially" do
+        assert !FakeModel.reload?
+      end
+
+      should "want to be reloaded once signaled by the class method" do
+        FakeModel.reload!
+        assert FakeModel.reload?
+      end
+
+      should "want to be reloaded once signaled by the instance method" do
+        @model.reload!
+        assert FakeModel.reload?
+      end
+
+      should "not want to be reloaded once reloaded! is called" do
+        @model.reload!
+        assert FakeModel.reload?
+        FakeModel.reloaded!
+        assert !FakeModel.reload?
+      end
+    end
+
+    context "with inheritance" do
+      class SubModel < FakeModel
+      end
+
+      setup do
+        @lazy = FakeModel.new
+        @sub = SubModel.new
+      end
+
+      should "not interfere with each others reload flags" do
+        @lazy.reload!
+        assert !SubModel.reload?
+        assert FakeModel.reload?
+      end
+    end
+  end
+
+  context "errors for relationship default implementation" do
+    setup do
+      @klass = FakeModel
+    end
+
+    should "return the errors on the item" do
+      errors = mock("errors")
+      item = mock("item")
+      item.stubs(:errors).returns(errors)
+      assert_equal errors, @klass.errors_for_relationship(nil, item)
+    end
+
+    should "return nil if the item doesn't respond to errors" do
+      assert_nil @klass.errors_for_relationship(nil, 7)
+    end
+  end
+
+  context "lazy attributes and relationships" do
+    class LazyModel < VirtualBox::AbstractModel
+      attribute :foo, :lazy => true
+      attribute :bar
+      relationship :foos, AbstractModelTest::Foo, :lazy => true
+      relationship :bars, AbstractModelTest::Bar, :lazy => true
+    end
+
+    setup do
+      @model = LazyModel.new
+    end
+
+    should "return false on lazy_attribute? for all attributes if new" do
+      assert !@model.lazy_attribute?(:foo)
+      assert !@model.lazy_relationship?(:foos)
+    end
+  end
+
+  context "inspecting" do
+    setup do
+      @model = FakeModel.new
+    end
+
+    should "generate the proper inspect string" do
+      assert_equal "#<AbstractModelTest::FakeModel :bar=nil, :bars=..., :foo=nil, :foos=...>", @model.inspect
+    end
+
+    should "turn attributes which are AbstractModels into classes" do
+      @model.foo = @model.dup
+      assert_equal "#<AbstractModelTest::FakeModel :bar=nil, :bars=..., :foo=#<AbstractModelTest::FakeModel>, :foos=...>", @model.inspect
+    end
+
+    should "turn attributes which are AbstractInterfaces into classes" do
+      @model.foo = VirtualBox::COM::Util.versioned_interface(:VirtualBox).new(VirtualBox::COM::Implementer::Nil, nil)
+      assert_equal "#<AbstractModelTest::FakeModel :bar=nil, :bars=..., :foo=#<VirtualBox::COM::Interface::Version_3_2_X::VirtualBox>, :foos=...>", @model.inspect
+    end
+  end
+
+  context "validation" do
+    setup do
+      @model = FakeModel.new
+    end
+
+    should "clear all previous errors" do
+      @model.expects(:clear_errors).once
+      @model.validate
+    end
+
+    should "call validate_relationship on each relationship class" do
+      Foo.expects(:validate_relationship).once.with(@model, nil)
+      @model.validate
+    end
+
+    should "forward arguments to validate_relationship" do
+      Foo.expects(:validate_relationship).once.with(@model, nil, "HELLO")
+      @model.validate("HELLO")
+    end
+
+    should "succeed if all relationships succeeded" do
+      Foo.expects(:validate_relationship).returns(true)
+      assert @model.validate
+    end
+
+    should "fail if one relationship failed to validate" do
+      Foo.expects(:validate_relationship).returns(true)
+      Bar.expects(:validate_relationship).returns(false)
+      assert !@model.validate
+    end
+
+    context "errors" do
+      should "return the errors of the relationships, as well as the model itself" do
+        @model.foo = nil
+        assert !@model.validate
+
+        @model.validates_presence_of(:foo)
+        Foo.expects(:errors_for_relationship).with(@model, nil).returns("BAD")
+        errors = @model.errors
+        assert errors.has_key?(:foos)
+        assert_equal "BAD", errors[:foos]
+        assert errors.has_key?(:foo)
+      end
+    end
+  end
+
+  context "new/existing records" do
+    setup do
+      @model = FakeModel.new
+    end
+
+    should "be a new record by default" do
+      assert @model.new_record?
+    end
+
+    should "not be a new record if populate_attributes is called" do
+      @model.populate_attributes({})
+      assert !@model.new_record?
+    end
+
+    should "not be a new record after saving" do
+      assert @model.new_record?
+      @model.save
+      assert !@model.new_record?
+    end
+
+    should "become a new record again if new_record! is called" do
+      assert @model.new_record?
+      @model.save
+      assert !@model.new_record?
+      @model.new_record!
+      assert @model.new_record?
+    end
+
+    should "become an existing record if existing_record! is called" do
+      assert @model.new_record?
+      @model.existing_record!
+      assert !@model.new_record?
+    end
+  end
+
+  context "parent machine" do
+    setup do
+      # Create a subclass of VM and no-op the initialize so it doesn't
+      # try to populate VM attributes or relationships
+      @root = Class.new(VirtualBox::VM)
+      @root.class_eval("def initialize; end")
+      @root = @root.new
+
+      @leaf = @root
+      3.times do |i|
+        child = Class.new(VirtualBox::AbstractModel)
+        child.attribute(:parent, :readonly => true, :property => false)
+        child = child.new
+        child.write_attribute(:parent, @leaf)
+        @leaf = child
+      end
+    end
+
+    should "get the parent" do
+      # Sanity test
+      assert_equal @root, @leaf.parent.parent.parent
+      assert @root.is_a?(VirtualBox::VM)
+
+      # Actual test
+      assert_equal @root, @leaf.parent_machine
+    end
+  end
+
+  context "subclasses" do
+    class FakeTwoModel < FakeModel
+      attribute :baz
+    end
+
+    setup do
+      @model = FakeTwoModel.new
+      @model.populate_attributes({
+        :foo => "foo",
+        :bar => "bar",
+        :baz => "baz"
+      })
+    end
+
+    should "have access to parents attributes" do
+      assert_nothing_raised do
+        assert_equal "foo", @model.foo
+      end
+    end
+  end
+
+  context "destroying" do
+    setup do
+      @model = FakeModel.new
+    end
+
+    should "call destroy_relationship only for dependent relationships" do
+      Foo.expects(:destroy_relationship).never
+      Bar.expects(:destroy_relationship).once
+
+      @model.destroy
+    end
+
+    should "forward any arguments to the destroy method" do
+      Bar.expects(:destroy_relationship).with(@model, anything, "HELLO").once
+      @model.destroy("HELLO")
+    end
+  end
+
+  context "saving" do
+    setup do
+      @model = FakeModel.new
+      @model.populate_attributes({
+        :foo => "foo",
+        :bar => "bar"
+      })
+    end
+
+    should "call save_attribute for only attributes which have changed" do
+      @model.foo = "foo2"
+      assert @model.foo_changed?
+      assert !@model.bar_changed?
+      @model.expects(:save_attribute).with(:foo, "foo2").once
+      @model.save
+    end
+
+    should "clear dirty state once saved" do
+      @model.foo = "foo2"
+      assert @model.foo_changed?
+      @model.save
+      assert !@model.foo_changed?
+    end
+
+    should "forward parameters through" do
+      @model.expects(:save_attribute).with(:foo, "foo2", "YES").once
+      Foo.expects(:save_relationship).with(@model, anything, "YES").once
+
+      @model.foo = "foo2"
+      @model.save("YES")
+    end
+
+    should "return true if succeeds" do
+      assert @model.save
+    end
+  end
+
+  context "save!" do
+    setup do
+      @model = FakeModel.new
+    end
+
+    should "raise an exception if save failed" do
+      args = %W[foo bar baz]
+      @model.expects(:save).with(*args).returns(false)
+      assert_raises(VirtualBox::Exceptions::ValidationFailedException) {
+        @model.save!(*args)
+      }
+    end
+
+    should "not raise an exception if save succeeds" do
+      @model.expects(:save).returns(true)
+      assert_nothing_raised { @model.save! }
+    end
+  end
+
+  context "populating relationships and attributes" do
+    setup do
+      @model = FakeModel.new
+    end
+
+    context "populating attributes" do
+      should "populate relationships at the same time as attributes" do
+        Foo.expects(:populate_relationship).once
+        @model.populate_attributes({})
+      end
+
+      should "not populate relationships if :ignore_relationships is true" do
+        Foo.expects(:populate_relationship).never
+        @model.populate_attributes({}, :ignore_relationships => true)
+      end
+
+      should "cause the model to become an existing record" do
+        assert @model.new_record?
+        @model.populate_attributes({})
+        assert !@model.new_record?
+      end
+
+      should "not cause dirtiness" do
+        assert_nil @model.foo
+        @model.populate_attributes({ :foo => "foo" })
+        assert_equal "foo", @model.foo
+        assert !@model.changed?
+      end
+    end
+
+    context "populating relationships" do
+      should "cause the model to become an existing record" do
+        assert @model.new_record?
+        @model.populate_relationships({})
+        assert !@model.new_record?
+      end
+
+      should "not cause dirtiness" do
+        # TODO: This test doesn't do much right now. We need to actually compare
+        # the relationship values for dirtiness.
+        @model.populate_relationships({ :foo => "foo" })
+        assert !@model.changed?
+      end
+    end
+
+    context "populating a single relationship" do
+      should "cause the model to become an existing record" do
+        assert @model.new_record?
+        @model.populate_relationship(:foos, {})
+        assert !@model.new_record?
+      end
+
+      should "not cause dirtiness" do
+        @model.populate_relationship(:foos, {})
+        assert !@model.changed?
+      end
+    end
+  end
+
+  context "integrating interface attributes" do
+    setup do
+      @model = FakeModel.new
+    end
+
+    should "clear the dirty state of an attribute after saving" do
+      key = :foo
+      interface = :bar
+      @model.expects(:clear_dirty!).with(key).once
+      @model.save_interface_attribute(key, interface)
+    end
+  end
+
+  context "integrating relatable" do
+    setup do
+      @model = FakeModel.new
+    end
+
+    context "saving all changed interface attributes" do
+      setup do
+        @interface = mock("interface")
+        @changes = [[:a, []], [:b, []], [:c, []]]
+        @model.stubs(:changes).returns(@changes)
+      end
+
+      should "save each" do
+        @model.changes.each do |key, options|
+          @model.expects(:save_interface_attribute).with(key, @interface)
+        end
+
+        @model.save_changed_interface_attributes(@interface)
+      end
+    end
+
+    context "with dirty" do
+      should "set dirty state when a relationship is set" do
+        assert !@model.changed?
+        @model.foos = "foo"
+        assert @model.changed?
+      end
+    end
+  end
+
+  context "integrating attributable and dirty" do
+    setup do
+      @model = FakeModel.new
+    end
+
+    should "not affect dirtiness with populate_attributes" do
+      assert !@model.changed?
+      @model.populate_attributes({
+        :foo => "foo2"
+      })
+
+      assert !@model.changed?
+      assert_equal "foo2", @model.foo
+    end
+
+    should "mark dirtiness on write_attribute" do
+      assert !@model.changed?
+      @model.write_attribute(:foo, "foo2")
+      assert @model.changed?
+      assert @model.foo_changed?
+      assert_equal "foo2", @model.foo
+    end
+
+    should "not mark dirtiness on write_attribute if the attribute is lazy and not yet loaded" do
+      @model.expects(:lazy_attribute?).with(:foo).returns(true)
+      @model.expects(:loaded_attribute?).with(:foo).returns(false)
+      @model.expects(:set_dirty!).never
+      @model.write_attribute(:foo, "foo2")
+    end
+  end
+end