virtualbox 0.4.1 → 0.4.2

data/test/virtualbox/abstract_model_test.rb

@@ -5,51 +5,61 @@ class AbstractModelTest < Test::Unit::TestCase
     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
     attribute :bar
     relationship :foos, Foo
     relationship :bars, Bar, :dependent => :destroy
   end
-  
+
+  context "inspecting" do
+    setup do
+      @model = FakeModel.new
+    end
+
+    should "generate the proper inspect string" do
+      assert_equal "#<AbstractModelTest::FakeModel :foo=nil, :bar=nil, :foos=..., :bars=...>", @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
@@ -64,7 +74,7 @@ class AbstractModelTest < Test::Unit::TestCase
       end
     end
   end
-  
+
   context "new/existing records" do
     setup do
       @model = FakeModel.new
@@ -73,18 +83,18 @@ class AbstractModelTest < Test::Unit::TestCase
     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
@@ -92,19 +102,19 @@ class AbstractModelTest < Test::Unit::TestCase
       @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 "subclasses" do
     class FakeTwoModel < FakeModel
       attribute :baz
     end
-    
+
     setup do
       @model = FakeTwoModel.new
       @model.populate_attributes({
@@ -113,32 +123,32 @@ class AbstractModelTest < Test::Unit::TestCase
         :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
@@ -147,7 +157,7 @@ class AbstractModelTest < Test::Unit::TestCase
         :bar => "bar"
       })
     end
-    
+
     should "call save_attribute for only attributes which have changed" do
       @model.foo = "foo2"
       assert @model.foo_changed?
@@ -155,66 +165,66 @@ class AbstractModelTest < Test::Unit::TestCase
       @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 relatable" do
     setup do
       @model = FakeModel.new
     end
-    
+
     should "set dirty state when a relationship is set" do
       assert !@model.changed?
       @model.foos = "foo"
       assert @model.changed?
     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")

data/test/virtualbox/attached_device_test.rb

@@ -10,15 +10,15 @@ class AttachedDeviceTest < Test::Unit::TestCase
 
     @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 "validations" do
     setup do
       @ad = VirtualBox::AttachedDevice.new
@@ -26,49 +26,49 @@ class AttachedDeviceTest < Test::Unit::TestCase
       @ad.port = 7
       @ad.added_to_relationship(@caller)
     end
-    
+
     should "be valid with all fields" do
       assert @ad.valid?
     end
-    
+
     should "be invalid with no image" do
       @ad.image = nil
       assert !@ad.valid?
     end
-    
+
     should "be invalid with no port" do
       @ad.port = nil
       assert !@ad.valid?
     end
-    
+
     should "be invalid if not in a relationship" do
       @ad.write_attribute(:parent, nil)
       assert !@ad.valid?
     end
   end
-  
+
   context "medium" do
     setup do
       @ad = VirtualBox::AttachedDevice.new
       @hd = VirtualBox::HardDrive.new
       @hd.write_attribute(:uuid, @uuid)
     end
-    
+
     should "be 'none' when image is nil" do
       assert_equal "none", @ad.medium
     end
-    
+
     should "be the uuid of the image if its not nil" do
       @ad.image = @hd
       assert_equal @hd.uuid, @ad.medium
     end
-    
+
     should "be 'emptydrive' if the image is an empty drive" do
       @ad.image = VirtualBox::DVD.empty_drive
       assert_equal "emptydrive", @ad.medium
     end
   end
-  
+
   context "saving an existing device" do
     setup do
       @value = VirtualBox::AttachedDevice.populate_relationship(@caller, @data)
@@ -76,46 +76,46 @@ class AttachedDeviceTest < Test::Unit::TestCase
       @value.image = VirtualBox::DVD.empty_drive
       assert @value.changed?
     end
-    
+
     should "not do anything if the device isn't change" do
       @value.clear_dirty!
       assert !@value.changed?
-      
+
       VirtualBox::Command.expects(:vboxmanage).never
       @value.save
     end
-    
+
     should "call vboxmanage" do
       VirtualBox::Command.expects(:vboxmanage).once
       @value.save
     end
-    
+
     should "return false and not call vboxmanage if invalid" do
       VirtualBox::Command.expects(:vboxmanage).never
       @value.expects(:valid?).returns(false)
       assert !@value.save
     end
-    
+
     should "not call destroy if the port didn't change" do
       @value.expects(:destroy).never
       assert !@value.port_changed?
       assert @value.save
     end
-    
+
     should "call destroy with the old port if the port changed" do
       @value.expects(:destroy).with({:port => @value.port}, false)
       @value.port = 7
       assert @value.port_changed?
       assert @value.save
     end
-    
+
     should "call destroy with the raise errors flag" do
       @value.expects(:destroy).with(anything, true).once
       @value.port = 7
       @value.save(true)
     end
   end
-  
+
   context "creating a new attached device" do
     setup do
       @image = VirtualBox::HardDrive.new
@@ -123,26 +123,26 @@ class AttachedDeviceTest < Test::Unit::TestCase
       @ad.image = @image
       @ad.port = 3
     end
-    
+
     should "return false and not call vboxmanage if invalid" do
       VirtualBox::Command.expects(:vboxmanage).never
       @ad.expects(:valid?).returns(false)
       assert !@ad.save
     end
-    
+
     should "raise a ValidationFailedException if invalid and raise_errors is true" do
       @ad.expects(:valid?).returns(false)
       assert_raises(VirtualBox::Exceptions::ValidationFailedException) {
         @ad.save(true)
       }
     end
-    
+
     context "has a parent" do
       setup do
         @ad.added_to_relationship(@caller)
         VirtualBox::Command.stubs(:vboxmanage)
       end
-      
+
       should "not call destroy since its a new record" do
         @ad.expects(:destroy).never
         assert @ad.save
@@ -161,20 +161,20 @@ class AttachedDeviceTest < Test::Unit::TestCase
       should "return true if the command was a success" do
         assert @ad.save
       end
-      
+
       should "raise an exception if true sent to save and error occured" do
         VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
         assert_raises(VirtualBox::Exceptions::CommandFailedException) {
           @ad.save(true)
         }
       end
-      
+
       should "not be a new record after saving" do
         assert @ad.new_record?
         assert @ad.save
         assert !@ad.new_record?
       end
-      
+
       should "not be changed after saving" do
         assert @ad.changed?
         assert @ad.save
@@ -182,40 +182,40 @@ class AttachedDeviceTest < Test::Unit::TestCase
       end
     end
   end
-  
+
   context "constructor" do
     should "call populate_from_data if 3 args are given" do
       VirtualBox::AttachedDevice.any_instance.expects(:populate_from_data).with(1,2,3).once
       VirtualBox::AttachedDevice.new(1,2,3)
     end
-    
+
     should "call populate_attributes if 1 arg is given" do
       VirtualBox::AttachedDevice.any_instance.expects(:populate_attributes).with(1).once
       ad = VirtualBox::AttachedDevice.new(1)
       assert ad.new_record?
     end
-    
+
     should "raise a NoMethodError if anything other than 0,1,or 3 arguments" do
       # 9 seems like a reasonable max (maybe just a bit unreasonable!)
       2.upto(9) do |i|
         next if i == 3
         args = Array.new(i, "A")
-        
+
         assert_raises(NoMethodError) {
           VirtualBox::AttachedDevice.new(*args)
         }
       end
     end
   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
 
@@ -228,7 +228,7 @@ class AttachedDeviceTest < Test::Unit::TestCase
 
       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)
@@ -236,69 +236,69 @@ class AttachedDeviceTest < Test::Unit::TestCase
       VirtualBox::Command.expects(:vboxmanage).in_sequence(shell_seq)
       @value.destroy
     end
-    
+
     should "destroy with the specified port if set" do
       VirtualBox::Command.expects(:vboxmanage).with("storageattach #{VirtualBox::Command.shell_escape(@vm.name)} --storagectl #{VirtualBox::Command.shell_escape(@caller.name)} --port 80 --device 0 --medium none")
       @value.destroy(:port => 80)
     end
-    
+
     should "destroy with the default port if not other port is specified" do
       VirtualBox::Command.expects(:vboxmanage).with("storageattach #{VirtualBox::Command.shell_escape(@vm.name)} --storagectl #{VirtualBox::Command.shell_escape(@caller.name)} --port #{@value.port} --device 0 --medium none")
       @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
-    
+
     should "return false if destroy failed" do
       VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
       assert !@value.destroy
     end
-    
+
     should "raise an exception if destroy failed and an error occured" do
       VirtualBox::Command.stubs(:vboxmanage).raises(VirtualBox::Exceptions::CommandFailedException)
       assert_raises(VirtualBox::Exceptions::CommandFailedException) {
         @value.destroy({}, true)
       }
     end
-    
+
     should "forward raise_errors flag to image.destroy" do
       @image.expects(:destroy).with(true).once
       @value.destroy({:destroy_image => true}, 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 "none", obj.medium
       assert_equal "322f79fd-7da6-416f-a16f-e70066ccf165", obj.uuid
       assert_equal 0, obj.port
-      
+
       obj = @value[1]
       assert_equal "none", obj.medium
       assert_nil obj.uuid