bbrowning-virtualbox 0.7.6.dev

data/test/virtualbox/proxies/collection_test.rb

@@ -0,0 +1,102 @@
+require File.expand_path("../../../test_helper", __FILE__)
+
+class CollectionTest < Test::Unit::TestCase
+  setup do
+    @parent = mock("parent")
+    @item_klass = mock("item_klass")
+    @klass = VirtualBox::Proxies::Collection
+    @collection = @klass.new(@parent, @item_klass)
+  end
+
+  should "be a subclass of Array" do
+    assert @collection.is_a?(Array)
+  end
+
+  context "creating" do
+    should "call create on the item klass and put it in the array" do
+      result = mock("result")
+      @item_klass.expects(:create).with(@collection).returns(result)
+      @collection.create
+      assert @collection.include?(result)
+    end
+
+    should "pass in any additional arguments if given" do
+      blah = mock("some blah")
+      @collection = @klass.new(@parent, @item_klass, blah)
+      @item_klass.expects(:create).with(@collection, blah).returns(nil)
+      @collection.create
+    end
+
+    should "pass in additional arguments from the call" do
+      result = mock("result")
+      @item_klass.expects(:create).with(@collection, :foo).returns(result)
+      assert_equal result, @collection.create(:foo)
+    end
+
+    should "do nothing if klass doesn't respond to create" do
+      previous_length = @collection.length
+      assert_nothing_raised { assert_nil @collection.create }
+      assert_equal previous_length, @collection.length
+    end
+  end
+
+  context "errors" do
+    should "return the errors of all the elements" do
+      errors = []
+      3.times do |i|
+        error = "error#{i}"
+        item = mock("item")
+        item.stubs(:errors).returns(error)
+        errors << error
+        @collection << item
+      end
+
+      assert_equal errors, @collection.errors
+    end
+  end
+
+  context "element callbacks" do
+    setup do
+      @item = mock("item")
+    end
+
+    context "<<" do
+      should "not call added_to_relationship if it doesn't exist" do
+        assert_nothing_raised { @collection << @item }
+      end
+
+      should "call added_to_relationship on the item when its added to a collection" do
+        @item.expects(:added_to_relationship).with(@collection).once
+        @collection << @item
+      end
+    end
+
+    context "delete" do
+      should "not call removed_from_relationship if it doesn't exist" do
+        @collection << @item
+        assert_nothing_raised { @collection.delete(@item) }
+      end
+
+      should "call removed_from_relationship on the item when its deleted" do
+        @collection << @item
+        @item.expects(:removed_from_relationship).with(@collection).once
+        @collection.delete(@item)
+      end
+
+      should "not call removed_from_relationship if no_callback is set" do
+        @collection << @item
+        @item.expects(:removed_from_relationship).never
+        @collection.delete(@item, true)
+      end
+    end
+
+    context "clearing" do
+      should "call removed_from_relationship if clear is called" do
+        @collection << @item
+        @item.expects(:removed_from_relationship).with(@collection).once
+        @collection.clear
+        assert @collection.empty?
+      end
+    end
+  end
+end

data/test/virtualbox/shared_folder_test.rb

@@ -0,0 +1,219 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class SharedFolderTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::SharedFolder
+    @interface = mock("interface")
+    @parent = mock("parent")
+  end
+
+  context "initializing" do
+    should "load attributes from the machine" do
+      @klass.any_instance.expects(:initialize_attributes).with(@interface).once
+      @klass.new(@interface)
+    end
+
+    should "not load attributes if new record" do
+      @klass.any_instance.expects(:initialize_attributes).never
+      @klass.new
+    end
+  end
+
+  context "initializing attributes" do
+    setup do
+      @klass.any_instance.stubs(:load_interface_attributes)
+      @klass.any_instance.stubs(:populate_relationships)
+    end
+
+    should "load interface attribtues" do
+      @klass.any_instance.expects(:load_interface_attributes).with(@interface).once
+      @klass.new(@interface)
+    end
+
+    should "not be dirty" do
+      @instance = @klass.new(@interface)
+      assert !@instance.changed?
+    end
+
+    should "be existing record" do
+      @instance = @klass.new(@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)
+
+        @collection = []
+        @interface.stubs(:shared_folders).returns(@collection)
+      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 shared folder" do
+        5.times { |i| @collection << mock("#{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(nil, @interface)
+      end
+    end
+
+    context "saving relationship" do
+      should "call save on each item" do
+        items = (1..5).to_a.collect do |i|
+          item = mock("item-#{i}")
+          item.expects(:save).once
+          item
+        end
+
+        @klass.save_relationship(nil, items)
+      end
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @klass.any_instance.stubs(:load_interface_attributes)
+      @instance = @klass.new(@interface)
+      @instance.stubs(:parent_machine).returns(@parent)
+      @collection = VirtualBox::Proxies::Collection.new(@parent)
+      @collection << @instance
+
+      @parent_interface = mock("interface")
+      @parent.stubs(:interface).returns(@parent_interface)
+
+      @name = "foo"
+      @machine = mock("machine")
+      @machine.stubs(:remove_shared_folder).with(@name)
+
+      @session = mock("session")
+      @session.stubs(:machine).returns(@machine)
+
+      @parent.stubs(:with_open_session).yields(@session)
+    end
+
+    context "saving" do
+      setup do
+        @instance.stubs(:valid?).returns(true)
+      end
+
+      should "do nothing if its not a new record and its not changed" do
+        assert !@instance.new_record?
+        assert !@instance.changed?
+        assert @instance.save
+      end
+
+      should "raise an exception if invalid" do
+        @instance.name = "foo_bar" # To set the changed flag
+        @instance.expects(:valid?).returns(false)
+
+        assert_raises(VirtualBox::Exceptions::ValidationFailedException) {
+          @instance.save
+        }
+      end
+
+      should "destroy then create" do
+        @instance.name = "foo_bar"
+        assert !@instance.new_record? # sanity
+
+        save_seq = sequence("save_seq")
+        @instance.expects(:destroy).with(false).once.in_sequence(save_seq)
+        @instance.expects(:create).once.in_sequence(save_seq)
+
+        @instance.save
+      end
+
+      should "just create (not destroy) if its a new record" do
+        @instance.new_record!
+
+        @instance.expects(:destroy).never
+        @instance.expects(:create).once
+
+        @instance.save
+      end
+    end
+
+    context "creating" do
+      setup do
+        @instance.new_record!
+
+        @instance.name = "foo"
+        @instance.host_path = "/bar"
+        @instance.writable = true
+
+        @machine.stubs(:create_shared_folder)
+      end
+
+      should "do nothing if its an existing record" do
+        @instance.existing_record!
+        @machine.expects(:create_shared_folder).never
+        @instance.create
+      end
+
+      should "create the shared folder" do
+        create_seq = sequence("create_seq")
+        @machine.expects(:create_shared_folder).with(@instance.name, @instance.host_path, @instance.writable).once.in_sequence(create_seq)
+        @instance.create
+      end
+
+      should "not be a new record after saving" do
+        assert @instance.new_record?
+        @instance.create
+        assert !@instance.new_record?
+      end
+
+      should "not be dirty after saving" do
+        assert @instance.changed?
+        @instance.create
+        assert !@instance.changed?
+      end
+    end
+
+    context "destroying" do
+      setup do
+        @name = "foo"
+        @instance.stubs(:name).returns(@name)
+        @machine.stubs(:remove_shared_folder).with(@name)
+      end
+
+      should "remove itself from it's collection" do
+        assert @collection.include?(@instance)
+        @instance.destroy
+        assert !@collection.include?(@instance)
+      end
+
+      should "not remove itself from it's collection if specified" do
+        assert @collection.include?(@instance)
+        @instance.destroy(false)
+        assert @collection.include?(@instance)
+      end
+
+      should "destroy the shared folder on the parent" do
+        destroy_seq = sequence("destroy_seq")
+        @machine.expects(:remove_shared_folder).with(@name).in_sequence(destroy_seq)
+
+        @instance.destroy
+      end
+
+      should "mark as a new record" do
+        assert !@instance.new_record?
+        @instance.destroy
+        assert @instance.new_record?
+      end
+    end
+  end
+end

data/test/virtualbox/snapshot_test.rb

@@ -0,0 +1,231 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+class SnapshotTest < Test::Unit::TestCase
+  setup do
+    @klass = VirtualBox::Snapshot
+    @interface = mock("isnapshot")
+  end
+
+  context "class methods" do
+    context "populating relationships" do
+      setup do
+        @caller = mock("caller")
+      end
+
+      should "call populate_machine_relationship for VMs" do
+        vm = mock("vm")
+        vm.stubs(:is_a?).with(VirtualBox::COM::Util.versioned_interface(:Machine)).returns(true)
+        @klass.expects(:populate_machine_relationship).with(@caller, vm).once
+        @klass.populate_relationship(@caller, vm)
+      end
+
+      should "call populate_children_relationship for an array" do
+        @klass.expects(:populate_children_relationship).with(@caller, [1,2,3]).once
+        @klass.populate_relationship(@caller, [1,2,3])
+      end
+
+      should "call populate_parent_relationship for a snapshot" do
+        ss = mock("snapshot")
+        ss.stubs(:is_a?).returns(false)
+        ss.stubs(:is_a?).with(VirtualBox::COM::Util.versioned_interface(:Snapshot)).returns(true)
+        @klass.expects(:populate_parent_relationship).with(@caller, ss).once
+        @klass.populate_relationship(@caller, ss)
+      end
+
+      should "call populate_parent_relationship for nil" do
+        @klass.expects(:populate_parent_relationship).with(@caller, nil).once
+        @klass.populate_relationship(@caller, nil)
+      end
+    end
+
+    context "populating machine relationship" do
+      setup do
+        @caller = mock("caller")
+        @machine = mock("imachine")
+        @snapshot = mock("snapshot")
+        @machine.stubs(:current_snapshot).returns(@snapshot)
+      end
+
+      should "just initialize with machine" do
+        result = mock("result")
+        @klass.expects(:new).with(@snapshot).once.returns(result)
+        assert_equal result, @klass.populate_machine_relationship(@caller, @machine)
+      end
+
+      should "return nil if there is no current snapshot" do
+        @machine.expects(:current_snapshot).returns(nil)
+        assert_nil @klass.populate_machine_relationship(@caller, @machine)
+      end
+    end
+
+    context "populating parent relationship" do
+      setup do
+        @caller = mock("caller")
+        @parent = mock("parent")
+      end
+
+      should "just initialize with data" do
+        result = mock("result")
+        @klass.expects(:new).with(@parent).once.returns(result)
+        assert_equal result, @klass.populate_parent_relationship(@caller, @parent)
+      end
+
+      should "return nil if there is no parent" do
+        assert_nil @klass.populate_parent_relationship(@caller, nil)
+      end
+    end
+
+    context "populating children relationship" do
+      setup do
+        @instance = mock("instance")
+
+        @klass.stubs(:new).returns(@instance)
+      end
+
+      should "return a proxied collection" do
+        result = @klass.populate_children_relationship(nil, [])
+        assert result.is_a?(VirtualBox::Proxies::Collection)
+      end
+
+      should "call new for every machine" do
+        snapshots = []
+        5.times { |i| snapshots << mock("s#{i}") }
+
+        expected_result = []
+        new_seq = sequence("new_seq")
+        snapshots.each do |snapshot|
+          expected_value = "instance-#{snapshot.inspect}"
+          @klass.expects(:new).with(snapshot).in_sequence(new_seq).returns(expected_value)
+          expected_result << expected_value
+        end
+
+        assert_equal expected_result, @klass.populate_children_relationship(nil, snapshots)
+      end
+    end
+  end
+
+  context "initializing" do
+    should "load attributes from the snapshot" do
+      @klass.any_instance.expects(:initialize_attributes).with(@interface).once
+      @klass.new(@interface)
+    end
+
+    should "set the interface as the interface attribute" do
+      @klass.any_instance.stubs(:initialize_attributes)
+      instance = @klass.new(@interface)
+      assert_equal @interface, instance.interface
+    end
+  end
+
+  context "initializing attributes" do
+    setup do
+      @interface.stubs(:refresh_state)
+      @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 "not be dirty" do
+      @instance = @klass.new(@interface)
+      assert !@instance.changed?
+    end
+
+    should "be existing record" do
+      @instance = @klass.new(@interface)
+      assert !@instance.new_record?
+    end
+  end
+
+  context "with an instance" do
+    setup do
+      @klass.any_instance.stubs(:initialize_attributes)
+      @instance = @klass.new(@interface)
+    end
+
+    context "timestamp" do
+      setup do
+        @time = Time.at(Time.now.to_i, 0)
+        @timestamp = @time.to_i * 1000
+        @instance.stubs(:read_attribute).with(:time_stamp).returns(@timestamp)
+      end
+
+      should "convert to a Time object" do
+        assert @instance.time_stamp.is_a?(Time)
+      end
+
+      should "convert to a proper Time object" do
+        value = @instance.time_stamp
+        assert @time.eql?(value), "#{@time} != #{value}"
+      end
+    end
+
+    context "destroying" do
+      setup do
+        @machine = mock("machine")
+        @session = mock("session")
+        @console = mock("console")
+        @progress = mock("progress")
+        @uuid = "UUID!"
+
+        @instance.stubs(:uuid).returns(@uuid)
+        @instance.stubs(:machine).returns(@machine)
+        @machine.stubs(:with_open_session).yields(@session)
+        @session.stubs(:console).returns(@console)
+        @console.stubs(:delete_snapshot).returns(@progress)
+        @progress.stubs(:wait)
+      end
+
+      should "delete the proper snapshot" do
+        @console.expects(:delete_snapshot).with(@instance.uuid).once.returns(@progress)
+        @progress.expects(:wait)
+
+        @instance.destroy
+      end
+
+      should "pass in block to the wait method" do
+        foo = mock("foo")
+        @progress.expects(:wait).yields(foo)
+        foo.expects(:called).once
+
+        @instance.destroy do |obj|
+          obj.called
+        end
+      end
+    end
+
+    context "restoring" do
+      setup do
+        @machine = mock("machine")
+        @session = mock("session")
+        @console = mock("console")
+        @progress = mock("progress")
+
+        @instance.stubs(:machine).returns(@machine)
+        @machine.stubs(:with_open_session).yields(@session)
+        @session.stubs(:console).returns(@console)
+        @console.stubs(:restore_snapshot).returns(@progress)
+        @progress.stubs(:wait)
+      end
+
+      should "restore the proper snapshot" do
+        @console.expects(:restore_snapshot).with(@instance.interface).once.returns(@progress)
+        @progress.expects(:wait)
+
+        @instance.restore
+      end
+
+      should "pass in block to the wait method" do
+        foo = mock("foo")
+        @progress.expects(:wait).yields(foo)
+        foo.expects(:called).once
+
+        @instance.restore do |obj|
+          obj.called
+        end
+      end
+    end
+  end
+end