virtualbox 0.1.0

data/test/virtualbox/abstract_model/dirty_test.rb

@@ -0,0 +1,66 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class DirtyTest < Test::Unit::TestCase
+  class DirtyModel
+    include VirtualBox::AbstractModel::Dirty
+    
+    def initialize
+      @foo = "foo"
+      @bar = "bar"
+    end
+    
+    def foo=(value)
+      set_dirty!(:foo, @foo, value)
+      @foo = value
+    end
+    
+    def bar=(value)
+      set_dirty!(:bar, @bar, value)
+      @bar = value
+    end
+  end
+  
+  context "dirty attributes" do
+    setup do
+      @model = DirtyModel.new
+    end
+    
+    should "not be dirty initially" do
+      assert !@model.changed?
+    end
+    
+    should "be dirty after changing an attribute" do
+      assert !@model.changed? # sanity
+      @model.foo = "my value"
+      assert @model.changed?
+    end
+    
+    should "be able to clear dirty state" do
+      assert !@model.changed?
+      @model.foo = "my value"
+      assert @model.changed?
+      @model.clear_dirty!(:foo)
+      assert !@model.changed?
+    end
+    
+    should "show changes on specific field" do
+      assert !@model.changed?
+      @model.foo = "my value"
+      assert @model.foo_changed?
+      assert_equal ["foo", "my value"], @model.foo_change
+      assert_equal "foo", @model.foo_was
+    end
+    
+    should "show changes for the whole model" do
+      assert !@model.changed?
+      @model.foo = "foo2"
+      @model.bar = "bar2"
+      
+      assert @model.changed?
+      changes = @model.changes
+      assert_equal 2, changes.length
+      assert_equal ["foo", "foo2"], changes[:foo]
+      assert_equal ["bar", "bar2"], changes[:bar]
+    end
+  end
+end

data/test/virtualbox/abstract_model/relatable_test.rb

@@ -0,0 +1,141 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class RelatableTest < Test::Unit::TestCase
+  class Relatee
+    def self.populate_relationship(caller, data)
+      "FOO"
+    end
+  end
+  class BarRelatee; end
+  
+  class RelatableModel
+    include VirtualBox::AbstractModel::Relatable
+    
+    relationship :foos, Relatee
+    relationship :bars, BarRelatee
+  end
+  
+  setup do
+    @data = {}
+  end
+  
+  context "subclasses" do
+    class SubRelatableModel < RelatableModel
+      relationship :bars, Relatee
+    end
+    
+    setup do
+      @relationships = SubRelatableModel.relationships
+    end
+    
+    should "inherit relationships of parent" do
+      assert @relationships.has_key?(:foos)
+      assert @relationships.has_key?(:bars)
+    end
+    
+    should "inherit options of relationships" do
+      assert_equal Relatee, @relationships[: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
+    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 "saving relationships" do
+    setup do
+      @model = RelatableModel.new
+    end
+    
+    should "call save_relationship on the related class" do
+      Relatee.expects(:save_relationship).with(@model, @model.foos).once
+      @model.save_relationships
+    end
+    
+    should "forward parameters through" do
+      Relatee.expects(:save_relationship).with(@model, @model.foos, "YES").once
+      @model.save_relationships("YES")
+    end
+  end
+  
+  context "reading relationships" do
+    setup do
+      @model = RelatableModel.new
+    end
+    
+    should "provide a read method for relationships" do
+      assert_nothing_raised { @model.foos }
+    end
+  end
+  
+  context "populating relationships" do
+    setup do
+      @model = RelatableModel.new
+    end
+    
+    should "call populate_relationship on the related class" do
+      Relatee.expects(:populate_relationship).with(@model, @data).once
+      @model.populate_relationships(@data)
+    end
+    
+    should "properly save returned value as the value for the relationship" do
+      Relatee.expects(:populate_relationship).once.returns("HEY")
+      @model.populate_relationships(@data)
+      assert_equal "HEY", @model.foos
+    end
+  end
+end

data/test/virtualbox/abstract_model_test.rb

@@ -0,0 +1,146 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class AbstractModelTest < Test::Unit::TestCase
+  class Foo; end
+  class Bar; end
+  
+  class FakeModel < VirtualBox::AbstractModel
+    attribute :foo
+    attribute :bar
+    relationship :foos, Foo
+    relationship :bars, Bar, :dependent => :destroy
+  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
+  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 "call save_relationships" do
+      @model.expects(:save_relationships).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
+  end
+  
+  context "populating relationships and attributes" do
+    setup do
+      @model = FakeModel.new
+    end
+    
+    should "populate relationships at the same time as attributes" do
+      Foo.expects(:populate_relationship).once
+      @model.populate_attributes({})
+    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
+  end
+end

data/test/virtualbox/attached_device_test.rb

@@ -0,0 +1,92 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class AttachedDeviceTest < Test::Unit::TestCase
+  setup do
+    @data = {
+      :"foo controller-0-0" => "foomedium",
+      :"foo controller-imageuuid-0-0" => "322f79fd-7da6-416f-a16f-e70066ccf165",
+      :"foo controller-1-0" => "barmedium"
+    }
+
+    @vm = mock("vm")
+    @vm.stubs(:name).returns("foo")
+    
+    @caller = mock("caller")
+    @caller.stubs(:parent).returns(@vm)
+    @caller.stubs(:name).returns("Foo Controller")
+    
+    # Stub execute to make sure nothing actually happens
+    VirtualBox::Command.stubs(:execute).returns('')
+  end
+  
+  context "destroying" do
+    setup do
+      @value = VirtualBox::AttachedDevice.populate_relationship(@caller, @data)
+      @value = @value[0]
+      
+      @image = mock("image")
+      @value.stubs(:image).returns(@image)
+      
+      VirtualBox::Command.stubs(:execute)
+    end
+
+    should "simply call destroy on each object when destroying the relationship" do
+      obj_one = mock("one")
+      obj_two = mock("two")
+
+      obj_one.expects(:destroy).with("HELLO").once
+      obj_two.expects(:destroy).with("HELLO").once
+
+      VirtualBox::AttachedDevice.destroy_relationship(self, [obj_one, obj_two], "HELLO")
+    end
+    
+    should "shell escape VM name and storage controller name" do
+      shell_seq = sequence("shell_seq")
+      VirtualBox::Command.expects(:shell_escape).with(@vm.name).in_sequence(shell_seq)
+      VirtualBox::Command.expects(:shell_escape).with(@caller.name).in_sequence(shell_seq)
+      VirtualBox::Command.expects(:vboxmanage).in_sequence(shell_seq)
+      @value.destroy
+    end
+    
+    should "not destroy image by default" do
+      @image.expects(:destroy).never
+      @value.destroy
+    end
+    
+    should "destroy image if flag is set" do
+      @image.expects(:destroy).once
+      @value.destroy({
+        :destroy_image => true
+      })
+    end
+    
+    should "ignore destroy image flag if image is nil" do
+      @value.expects(:image).once.returns(nil)
+      @value.destroy({
+        :destroy_image => true
+      })
+    end
+  end
+  
+  context "populating relationships" do
+    setup do
+      @value = VirtualBox::AttachedDevice.populate_relationship(@caller, @data)
+    end
+    
+    should "create the correct amount of objects" do
+      assert_equal 2, @value.length
+    end
+    
+    should "create objects with proper values" do
+      obj = @value[0]
+      assert_equal "foomedium", obj.medium
+      assert_equal "322f79fd-7da6-416f-a16f-e70066ccf165", obj.uuid
+      assert_equal 0, obj.port
+      
+      obj = @value[1]
+      assert_equal "barmedium", obj.medium
+      assert_nil obj.uuid
+      assert_equal 1, obj.port
+    end
+  end
+end