bbrowning-virtualbox 0.7.6.dev

data/test/virtualbox/global_test.rb

@@ -0,0 +1,46 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class GlobalTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::Global
+  end
+
+  context "getting the global object" do
+    setup do
+      @lib = mock('lib')
+      VirtualBox::Lib.stubs(:lib).returns(@lib)
+      @klass.reset!
+    end
+
+    should "initialize the object with the lib once" do
+      instance =  mock("instance")
+      @klass.expects(:new).with(@lib).once.returns(instance)
+      assert_equal instance, @klass.global
+      assert_equal instance, @klass.global
+      assert_equal instance, @klass.global
+    end
+
+    should "initialize the object if reload is set" do
+      instance = mock("instance")
+      @klass.expects(:new).with(@lib).twice.returns(instance)
+      assert_equal instance, @klass.global
+      assert_equal instance, @klass.global(true)
+      assert_equal instance, @klass.global
+    end
+  end
+
+  context "with an instance" do
+    setup do
+      @lib = mock("lib")
+      @instance = @klass.new(@lib)
+    end
+
+    should "be an existing record, always" do
+      assert !@instance.new_record?
+    end
+
+    should "setup the lib attribute on initialization" do
+      assert_equal @lib, @instance.lib
+    end
+  end
+end

data/test/virtualbox/hard_drive_test.rb

@@ -0,0 +1,141 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class HardDriveTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::HardDrive
+    @interface = mock("interface")
+  end
+
+  context "device type" do
+    should "be :hard_disk" do
+      assert_equal :hard_disk, @klass.device_type
+    end
+  end
+
+  context "retrieving all hard drives" do
+    should "return an array of HardDrive objects" do
+      media = mock("media")
+      media.expects(:hard_drives).returns("foo")
+      global = mock("global")
+      global.expects(:media).returns(media)
+      VirtualBox::Global.expects(:global).returns(global)
+      assert_equal "foo", VirtualBox::HardDrive.all
+    end
+  end
+
+  context "finding a hard drive" do
+    setup do
+      @all = []
+      @klass.stubs(:all).returns(@all)
+    end
+
+    def mock_drive(uuid)
+      drive = mock("hd-#{uuid}")
+      drive.stubs(:uuid).returns(uuid)
+      drive
+    end
+
+    should "return nil if it doesn't exist" do
+      @all << mock_drive("foo")
+      assert_nil @klass.find("bar")
+    end
+
+    should "return the matching drive if it is found" do
+      drive = mock_drive("foo")
+      @all << mock_drive("bar")
+      @all << drive
+      assert_equal drive, @klass.find("foo")
+    end
+  end
+
+  context "with an instance" do
+    setup do
+      @klass.any_instance.stubs(:initialize_attributes)
+      @instance = @klass.new(@interface)
+    end
+
+    context "physical size" do
+      should "convert bytes to megabytes" do
+        nonnormalized = 37548181
+        normalized = @instance.bytes_to_megabytes(nonnormalized)
+        @instance.expects(:read_attribute).with(:physical_size).returns(nonnormalized)
+        assert_equal normalized, @instance.physical_size
+      end
+    end
+
+    context "cloning" do
+      setup do
+        @system_properties = mock("system_properties")
+        @virtualbox = mock("virtualbox")
+        @lib = mock("lib")
+        @new_medium = mock("new_medium")
+
+        @hard_disk_format = "VDI"
+        @hard_disk_folder = "foobar"
+
+        VirtualBox::Lib.stubs(:lib).returns(@lib)
+        @lib.stubs(:virtualbox).returns(@virtualbox)
+        @virtualbox.stubs(:system_properties).returns(@system_properties)
+        @system_properties.stubs(:default_hard_disk_format).returns(@hard_disk_format)
+        @system_properties.stubs(:default_hard_disk_folder).returns(@hard_disk_folder)
+      end
+
+      should "clone the hard drive" do
+        progress = mock("progress")
+        @instance.expects(:create_hard_disk_medium).with("/foo.vdi", nil).returns(@new_medium)
+        @interface.expects(:clone_to).with(@new_medium, :standard, nil).returns(progress)
+        progress.expects(:wait_for_completion).with(-1)
+
+        @instance.clone("/foo.vdi")
+      end
+    end
+  end
+
+  context "creating a hard drive" do
+    setup do
+      @klass.any_instance.stubs(:initialize_attributes)
+      @instance = @klass.new
+      @instance.stubs(:validate)
+
+      @system_properties = mock("system_properties")
+      @virtualbox = mock("virtualbox")
+      @lib = mock("lib")
+      @new_medium = mock("new_medium")
+
+      @hard_disk_format = "VDI"
+      @hard_disk_folder = "foobar"
+
+      VirtualBox::Lib.stubs(:lib).returns(@lib)
+      @lib.stubs(:virtualbox).returns(@virtualbox)
+      @virtualbox.stubs(:system_properties).returns(@system_properties)
+      @system_properties.stubs(:default_hard_disk_format).returns(@hard_disk_format)
+      @system_properties.stubs(:default_hard_disk_folder).returns(@hard_disk_folder)
+    end
+
+    should "return false unless the record is new" do
+      @instance.stubs(:new_record?).returns(false)
+      assert_equal false, @instance.create
+    end
+
+    should "raise exception unless the record is valid" do
+      @instance.stubs(:valid?).returns(false)
+      assert_raises(VirtualBox::Exceptions::ValidationFailedException) do
+        @instance.create
+      end
+    end
+
+    should "create the hard drive" do
+      logical_size = 1000
+      progress = mock("progress")
+      @instance.stubs(:location).returns(@hard_disk_folder)
+      @instance.stubs(:format).returns(@hard_disk_format)
+      @instance.stubs(:logical_size).returns(logical_size)
+      @instance.expects(:create_hard_disk_medium).with(@hard_disk_folder, @hard_disk_format).returns(@new_medium)
+      @new_medium.expects(:create_base_storage).with(logical_size, :standard).returns(progress)
+      progress.expects(:wait_for_completion).with(-1)
+
+      @instance.create
+    end
+  end
+
+end

data/test/virtualbox/host_network_interface_test.rb

@@ -0,0 +1,254 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class HostNetworkInterfaceTest < Test::Unit::TestCase
+  setup do
+    @interface = mock("interface")
+    @parent = mock("parent")
+
+    @klass = VirtualBox::HostNetworkInterface
+  end
+
+  context "class methods" do
+    context "populating relationships" do
+      setup do
+        @instance = mock("instance")
+
+        @interface.stubs(:network_interfaces).returns([])
+        @klass.stubs(:new).returns(@instance)
+      end
+
+      should "return a proxied collection" do
+        result = @klass.populate_relationship(nil, @interface)
+        assert result.is_a?(VirtualBox::Proxies::Collection)
+      end
+
+      should "call new for every interface" do
+        collection = []
+        @interface.stubs(:network_interfaces).returns(collection)
+        5.times { |i| collection << mock("a#{i}") }
+
+        expected_result = []
+        new_seq = sequence("new_seq")
+        collection.each do |item|
+          expected_value = "instance-#{item.inspect}"
+          @klass.expects(:new).with(item).in_sequence(new_seq).returns(expected_value)
+          expected_result << expected_value
+        end
+
+        assert_equal expected_result, @klass.populate_relationship(@parent, @interface)
+      end
+    end
+
+    context "creating" do
+      setup do
+        @interface = mock("interface")
+        @inet = mock("inet")
+        @progress = mock("progress")
+      end
+
+      should "create and return new instance" do
+        result = mock("result")
+        @interface.expects(:create_host_only_network_interface).returns([@inet, @progress]).once
+        @progress.expects(:wait)
+        @klass.expects(:new).with(@inet).returns(result)
+
+        assert_equal result, @klass.create(nil, @interface)
+      end
+    end
+  end
+
+  context "initializing" do
+    should "load attributes from the machine" do
+      @klass.any_instance.expects(:initialize_attributes).with(@interface).once
+      @klass.new(@interface)
+    end
+  end
+
+  context "initializing attributes" do
+    setup do
+      @klass.any_instance.stubs(:load_interface_attributes)
+    end
+
+    should "load interface attribtues" do
+      @klass.any_instance.expects(:load_interface_attributes).with(@interface).once
+      @klass.new(@interface)
+    end
+
+    should "be existing record" do
+      @instance = @klass.new(@interface)
+      assert !@instance.new_record?
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @klass.any_instance.stubs(:initialize_attributes)
+
+      @parent = mock("parent")
+      @interface = mock("interface")
+      @instance = @klass.new(@interface)
+      @instance.stubs(:interface).returns(@interface)
+      @instance.stubs(:parent).returns(@parent)
+      @collection = VirtualBox::Proxies::Collection.new(@parent)
+      @collection << @instance
+    end
+
+    context "attached VMs" do
+      setup do
+        @parent_parent = mock("parentparent")
+        @parent.stubs(:parent).returns(@parent_parent)
+
+        @vms = []
+        @parent_parent.stubs(:vms).returns(@vms)
+      end
+
+      def stub_vm(*interfaces)
+        adapters = []
+        vm = mock("vm")
+        vm.stubs(:network_adapters).returns(adapters)
+
+        interfaces.each do |name|
+          adapter = mock("adapter")
+          adapter.stubs(:host_interface).returns(name)
+          adapters << adapter
+        end
+
+        vm
+      end
+
+      should "return no VMs if none are using the interface" do
+        assert @instance.attached_vms.empty?
+      end
+
+      should "return only the VMs which are using the interface" do
+        name = "foo"
+        @instance.stubs(:name).returns(name)
+        result = stub_vm(name)
+        @vms << stub_vm("bar")
+        @vms << result
+        @vms << stub_vm("baz")
+
+        assert_equal [result], @instance.attached_vms
+      end
+    end
+
+    context "dhcp server" do
+      setup do
+        @host = mock("host")
+        @dhcp_servers = []
+        @parent.stubs(:parent).returns(@host)
+        @host.stubs(:dhcp_servers).returns(@dhcp_servers)
+        @instance.stubs(:interface_type).returns(:host_only)
+
+        @name = "foo"
+        @instance.stubs(:name).returns(@name)
+      end
+
+      def stub_dhcp_server(name, prefix=true)
+        name = "HostInterfaceNetworking-#{name}" if prefix
+
+        dhcp = mock("dhcp")
+        dhcp.stubs(:network_name).returns(name)
+        dhcp
+      end
+
+      should "return nil if interface type isn't host only" do
+        @instance.stubs(:interface_type).returns(:bridged)
+        assert_nil @instance.dhcp_server
+      end
+
+      should "return the DHCP server if it finds one" do
+        server = stub_dhcp_server(@name)
+        @dhcp_servers << server
+        assert_equal server, @instance.dhcp_server
+      end
+
+      should "create a DHCP server if it can't find one" do
+        result = mock("result")
+      end
+
+      should "not create a DHCP if specified and not found" do
+        @dhcp_servers.expects(:create).never
+        assert_nil @instance.dhcp_server(false)
+      end
+    end
+
+    context "enabling static IPV4" do
+      setup do
+        @interface.stubs(:enable_static_ip_config)
+        @instance.stubs(:reload)
+      end
+
+      should "enable the ip config" do
+        ip = :foo
+        netmask = :bar
+        @interface.expects(:enable_static_ip_config).with(ip, netmask).once
+        @instance.enable_static(ip, netmask)
+      end
+
+      should "by default use the current network mask" do
+        ip = :foo
+        @interface.expects(:enable_static_ip_config).with(ip, @instance.network_mask).once
+        @instance.enable_static(ip)
+      end
+
+      should "reload the instance" do
+        result = mock("result")
+        @instance.expects(:reload).returns(result)
+        assert_equal result, @instance.enable_static(:foo)
+      end
+    end
+
+    context "reloading" do
+      setup do
+        @interface = mock("parent_interface")
+        @parent.stubs(:interface).returns(@interface)
+      end
+
+      should "reload based on the interface found by the parent" do
+        result = mock("result")
+        @interface.expects(:find_host_network_interface_by_id).with(@instance.uuid).once.returns(result)
+        @instance.expects(:initialize_attributes).with(result).once
+        assert_equal @instance, @instance.reload
+      end
+    end
+
+    context "destroying" do
+      setup do
+        @interface = mock("parent_interface")
+        @progress = mock("progress")
+        @progress.stubs(:wait)
+        @parent.stubs(:interface).returns(@interface)
+        @interface.stubs(:remove_host_only_network_interface).returns(@progress)
+        @instance.stubs(:dhcp_server).returns(nil)
+        @instance.stubs(:interface_type).returns(:host_only)
+      end
+
+      should "do nothing if bridged" do
+        @instance.stubs(:interface_type).returns(:bridged)
+        @interface.expects(:remove_host_only_network_interface).never
+        assert !@instance.destroy
+      end
+
+      should "remove the network interface from VirtualBox" do
+        @interface.expects(:remove_host_only_network_interface).with(@instance.uuid).returns(@progress)
+
+        @instance.destroy
+      end
+
+      should "destroy the DHCP server if it exists" do
+        server = mock("server")
+        @instance.stubs(:dhcp_server).returns(server)
+        server.expects(:destroy).once
+
+        @instance.destroy
+      end
+
+      should "remove the instance from it's collection" do
+        assert @collection.include?(@instance)
+        @instance.destroy
+        assert !@collection.include?(@instance)
+      end
+    end
+  end
+end

data/test/virtualbox/host_test.rb

@@ -0,0 +1,94 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class HostTest < Test::Unit::TestCase
+  setup do
+    @parent = mock("parent")
+    @klass = VirtualBox::Host
+    @interface = mock("interface")
+  end
+
+  context "initializing" do
+    should "load attributes from the machine" do
+      @klass.any_instance.expects(:initialize_attributes).with(@parent, @interface).once
+      @klass.new(@parent, @interface)
+    end
+  end
+
+  context "initializing attributes" do
+    setup do
+      @klass.any_instance.stubs(:load_interface_attributes)
+      @klass.any_instance.stubs(:populate_relationship)
+    end
+
+    should "load interface attribtues" do
+      @klass.any_instance.expects(:load_interface_attributes).with(@interface).once
+      @klass.new(@parent, @interface)
+    end
+
+    should "populate the relationships" do
+      @klass.any_instance.expects(:populate_relationship).with(:network_interfaces, @interface).once
+      @klass.new(@parent, @interface)
+    end
+
+    should "setup the interface" do
+      instance = @klass.new(@parent, @interface)
+      assert_equal @interface, instance.interface
+    end
+
+    should "not be dirty" do
+      @instance = @klass.new(@parent, @interface)
+      assert !@instance.changed?
+    end
+
+    should "be existing record" do
+      @instance = @klass.new(@parent, @interface)
+      assert !@instance.new_record?
+    end
+  end
+
+  context "class methods" do
+    context "populating relationship" do
+      setup do
+        @instance = mock("instance")
+        @klass.stubs(:new).returns(@instance)
+      end
+
+      should "return a SystemProperties instance" do
+        result = @klass.populate_relationship(nil, @interface)
+        assert_equal @instance, result
+      end
+
+      should "call new for every shared folder" do
+        @klass.expects(:new).with(nil, @interface).returns(@instance)
+        result = @klass.populate_relationship(nil, @interface)
+        assert_equal @instance, result
+      end
+    end
+
+    context "saving relationship" do
+      setup do
+        @item = mock("item")
+      end
+
+      should "just call save on the item" do
+        @item.expects(:save)
+        @klass.save_relationship(nil, @item)
+      end
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @klass.any_instance.stubs(:load_interface_attributes)
+      @klass.any_instance.stubs(:populate_relationship)
+      @instance = @klass.new(@parent, @interface)
+    end
+
+    context "saving" do
+      should "save changed interface attributes" do
+        @instance.expects(:save_changed_interface_attributes).with(@interface)
+        @instance.save
+      end
+    end
+  end
+end