bbrowning-virtualbox 0.7.6.dev

data/lib/virtualbox/vrdp_server.rb

@@ -0,0 +1,59 @@
+module VirtualBox
+  # Represents the VRDP Server settings of a {VM}.
+  class VRDPServer < AbstractModel
+    attribute :parent, :readonly => true, :property => false
+    attribute :enabled, :boolean => true
+    attribute :ports
+    attribute :net_address
+    attribute :auth_type
+    attribute :auth_timeout
+    attribute :allow_multi_connection, :boolean => true
+    attribute :reuse_single_connection, :boolean => true
+
+    class << self
+      # Populates a relationship with another model.
+      #
+      # **This method typically won't be used except internally.**
+      #
+      # @return [VRDPServer]
+      def populate_relationship(caller, imachine)
+        data = new(caller, imachine.vrdp_server)
+      end
+
+      # Saves the relationship.
+      #
+      # **This method typically won't be used except internally.**
+      def save_relationship(caller, instance)
+        instance.save
+      end
+    end
+
+    def initialize(parent, vrdp_settings)
+      write_attribute(:parent, parent)
+
+      # Load the attributes and mark the whole thing as existing
+      load_interface_attributes(vrdp_settings)
+      clear_dirty!
+      existing_record!
+    end
+
+    def validate
+      super
+
+      validates_inclusion_of :enabled, :allow_multi_connection, :reuse_single_connection, :in => [true, false]
+      validates_format_of :ports, :with => /^[\d\s\-\.]+$/, :message => "must only contain numbers, spaces, dashes or periods."
+      validates_format_of :net_address, :with => /^[\w\d\-\.]+$/, :message => "must only contain latters, numbers, dashes or periods."
+      validates_inclusion_of :auth_type, :in => COM::Util.versioned_interface(:VRDPAuthType).map
+      validates_numericality_of :auth_timeout
+    end
+
+    def save
+      parent.with_open_session do |session|
+        machine = session.machine
+
+        # Save them
+        save_changed_interface_attributes(machine.vrdp_server)
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,18 @@
+# ruby-debug, not necessary, but useful if we have it
+begin
+  require 'ruby-debug'
+rescue LoadError; end
+
+require 'contest'
+require 'mocha'
+require 'virtualbox'
+
+# Data
+class Test::Unit::TestCase
+end
+
+# Initialize the FFI stuff. This is typically done dynamically when
+# FFI is initialized (on non-windows machines). Since the tests test
+# the FFI classes, we force initialize a specific version here. It
+# doesn't matter what version, since no actual FFI calls are made.
+VirtualBox::COM::FFI.setup("3.2.x") unless defined?(VirtualBox::COM::FFI::Version_3_2_X)

data/test/virtualbox/abstract_model/attributable_test.rb

@@ -0,0 +1,269 @@
+require File.expand_path("../../../test_helper", __FILE__)
+
+class AttributableTest < Test::Unit::TestCase
+  class EmptyAttributeModel
+    include VirtualBox::AbstractModel::Attributable
+  end
+
+  class AttributeModel < EmptyAttributeModel
+    attribute :foo
+    attribute :bar
+    attribute :boolean_bar, :boolean => true
+
+    def initialize
+      super
+    end
+  end
+
+  context "subclasses" do
+    class SubModel < AttributeModel
+      attribute :baz
+    end
+
+    should "have foo bar and baz" do
+      attributes = SubModel.attributes
+      assert attributes.has_key?(:foo)
+      assert attributes.has_key?(:bar)
+      assert attributes.has_key?(:baz)
+    end
+  end
+
+  context "attribute scopes" do
+    class AttributeScopeA < EmptyAttributeModel
+      attribute :foo
+      attribute_scope(:bar => 7) do
+        attribute :foo2
+
+        attribute_scope(:baz => 3) do
+          attribute :bazzed
+        end
+      end
+
+      attribute :foo3, :bar => 10
+    end
+
+    setup do
+      @klass = AttributeScopeA
+    end
+
+    should "use attribute scope" do
+      assert_equal 7, @klass.attributes[:foo2][:bar]
+    end
+
+    should "not use attribute scope outside of the block" do
+      assert !@klass.attributes[:foo].has_key?(:bar)
+      assert_equal 10, @klass.attributes[:foo3][:bar]
+    end
+
+    should "properly nest" do
+      bazzed = @klass.attributes[:bazzed]
+      assert_equal 3, bazzed[:baz]
+      assert_equal 7, bazzed[:bar]
+    end
+  end
+
+  context "attribute options" do
+    context "custom populate keys" do
+      class CustomPopulateModel < AttributeModel
+        attribute :foo, :populate_key => :foo_key
+      end
+
+      setup do
+        @model = CustomPopulateModel.new
+      end
+
+      should "use the populate key instead of the attribute name" do
+        @model.populate_attributes({
+          :foo => "not me!",
+          :foo_key => "bar"
+        })
+
+        assert_equal "bar", @model.foo
+      end
+    end
+
+    context "readonly attributes" do
+      class ReadonlyModel < AttributeModel
+        attribute :foo, :readonly => :readonly
+
+        def initialize
+          super
+          populate_attributes({ :foo => "foo" })
+        end
+      end
+
+      setup do
+        @model = ReadonlyModel.new
+      end
+
+      should "be readonly" do
+        assert @model.readonly_attribute?(:foo)
+      end
+
+      should "allow reading" do
+        assert_equal "foo", @model.foo
+      end
+
+      should "not allow writing" do
+        assert_raises(NoMethodError) { @model.foo = "YO" }
+      end
+    end
+
+    context "default values" do
+      class DefaultModel < EmptyAttributeModel
+        attribute :foo, :default => "FOO!"
+        attribute :bar
+      end
+
+      setup do
+        @model = DefaultModel.new
+      end
+
+      should "read default values" do
+        assert_equal "FOO!", @model.foo
+        assert_nil @model.bar
+      end
+    end
+
+    context "lazy loading" do
+      class LazyModel < EmptyAttributeModel
+        attribute :foo, :lazy => true
+        attribute :bar
+
+        def load_attribute(attribute)
+          write_attribute(attribute, "foo")
+        end
+      end
+
+      setup do
+        @model = LazyModel.new
+      end
+
+      should "return proper value for lazy_attribute?" do
+        assert @model.lazy_attribute?(:foo)
+        assert !@model.lazy_attribute?(:bar)
+        assert !@model.lazy_attribute?(:i_dont_exist)
+      end
+
+      should "load the lazy attribute on read" do
+        assert !@model.loaded_attribute?(:foo)
+        assert_equal "foo", @model.foo
+        assert @model.loaded_attribute?(:foo)
+      end
+
+      should "not be loaded initially, then should be loaded after being read" do
+        assert !@model.loaded_attribute?(:foo)
+        @model.foo
+        assert @model.loaded_attribute?(:foo)
+      end
+
+      should "mark as loaded if write_attribute is called on an attribute" do
+        assert !@model.loaded_attribute?(:foo)
+        @model.write_attribute(:foo, "bar")
+        assert @model.loaded_attribute?(:foo)
+        assert_equal "bar", @model.foo
+      end
+    end
+  end
+
+  context "populating attributes" do
+    setup do
+      @model = AttributeModel.new
+    end
+
+    should "write all valid attributes" do
+      new_attributes = {
+        :foo => "zxcv",
+        :bar => "qwerty"
+      }
+
+      @model.populate_attributes(new_attributes)
+      new_attributes.each do |k,v|
+        assert_equal v, @model.send(k)
+      end
+    end
+
+    should "not load nonexistent keys" do
+      new_attributes = {
+        :foo => "zxcv"
+      }
+
+      @model.populate_attributes(new_attributes)
+      assert @model.loaded_attribute?(:foo)
+      assert !@model.loaded_attribute?(:bar)
+    end
+  end
+
+  context "reading and writing attributes" do
+    class VersionedAttributeModel < AttributeModel
+      attribute :ver, :version => "3.1"
+    end
+
+    setup do
+      @model = VersionedAttributeModel.new
+      @model.populate_attributes({
+        :foo => "foo",
+        :bar => false,
+        :ver => "ver"
+      })
+
+      @checkstring = "HEY"
+    end
+
+    should "be able to read an entire hash of attributes" do
+      atts = @model.attributes
+      assert atts.is_a?(Hash)
+      assert atts.has_key?(:foo)
+      assert atts.has_key?(:bar)
+    end
+
+    should "be able to access boolean values with a '?'" do
+      @model.boolean_bar = true
+      assert @model.boolean_bar?
+      @model.boolean_bar = false
+      assert !@model.boolean_bar?
+    end
+
+    should "be able to write defined attributes" do
+      assert_nothing_raised {
+        @model.foo = @check_string
+      }
+    end
+
+    should "be able to read defined attributes" do
+      assert_nothing_raised {
+        assert_equal "foo", @model.foo
+      }
+    end
+
+    should "raise an exception if version not supported" do
+      VirtualBox.stubs(:version).returns("3.0.14")
+
+      assert_raises(VirtualBox::Exceptions::UnsupportedVersionException) {
+        @model.ver
+      }
+    end
+
+    should "read value if version supported" do
+      VirtualBox.stubs(:version).returns("3.1.8")
+
+      assert_nothing_raised {
+        assert_equal "ver", @model.ver
+      }
+    end
+
+    should "understand false values" do
+      assert_nothing_raised {
+        assert_equal false, @model.bar
+      }
+    end
+
+    should "raise an error if attempting to write an undefined attribute" do
+      assert_raises(NoMethodError) { @model.baz = @check_string }
+    end
+
+    should "raise an error if attempting to read an undefined attribute" do
+      assert_raises(NoMethodError) { @model.baz }
+    end
+  end
+end

data/test/virtualbox/abstract_model/dirty_test.rb

@@ -0,0 +1,83 @@
+require File.expand_path("../../../test_helper", __FILE__)
+
+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 "be able to clear dirty state on entire model" do
+      @model.foo = "changed"
+      @model.bar = "changed"
+      assert @model.changed?
+      @model.clear_dirty!
+      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 "return nil for field_was if its not changed" do
+      assert !@model.foo_changed?
+      assert_nil @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
+
+    should "still forward non-dirty magic methods up method_missing" do
+      assert_raises(NoMethodError) { @model.foobarbaz }
+    end
+  end
+end

data/test/virtualbox/abstract_model/interface_attributes_test.rb

@@ -0,0 +1,194 @@
+require File.expand_path("../../../test_helper", __FILE__)
+
+class InterfaceAttributesTest < Test::Unit::TestCase
+  class EmptyInterfaceAttributeModel
+    include VirtualBox::AbstractModel::Attributable
+    include VirtualBox::AbstractModel::InterfaceAttributes
+  end
+
+  class InterfaceAttributeModel < EmptyInterfaceAttributeModel
+    attribute :foo
+    attribute :foo2, :property_getter => :get_foo, :property_setter => :set_foo
+    attribute :foo3, :property => :grab_foo3, :readonly => true
+    attribute :foo4, :property => :put_foo4
+    attribute :bar, :property => false
+    attribute :ver, :version => "3.1.3"
+  end
+
+  context "converting spec to a proc" do
+    setup do
+      @instance = EmptyInterfaceAttributeModel.new
+      @interface = mock("interface")
+    end
+
+    context "symbols" do
+      should "convert to a proc which calls the symbol on the interface" do
+        result = mock("result")
+        proc = @instance.spec_to_proc(:foo)
+        @interface.expects(:foo).once.returns(result)
+        assert_equal result, proc.call(nil, @interface)
+      end
+
+      should "forward all parameters" do
+        result = mock("result")
+        proc = @instance.spec_to_proc(:foo)
+        @interface.expects(:foo).with(1, 2, 3).once.returns(result)
+        assert_equal result, proc.call(nil, @interface, :key, 1, 2, 3)
+      end
+    end
+
+    context "procs" do
+      should "leave proc as is" do
+        result = mock("result")
+        proc = Proc.new { |m| result }
+        converted = @instance.spec_to_proc(proc)
+        assert_equal proc, converted
+        assert_equal result, converted.call(@interface)
+      end
+    end
+  end
+
+  context "loading a single interface attribute" do
+    setup do
+      @instance = InterfaceAttributeModel.new
+      @interface = mock("interface")
+      @interface.stubs(:foo).returns("foo")
+    end
+
+    should "return immediately if not a valid attribute" do
+      @proc.expects(:call).never
+      @instance.load_interface_attribute(:baz, @interface)
+    end
+
+    should "return immediately if is marked as a non-property" do
+      @proc.expects(:call).never
+      @instance.load_interface_attribute(:bar, @interface)
+    end
+
+    should "return immediately if version mismatch" do
+      VirtualBox.stubs(:version).returns("3.2.4")
+      @interface.expects(:ver).never
+      @instance.load_interface_attribute(:ver, @interface)
+    end
+
+    should "load the attribute if version matches" do
+      VirtualBox.stubs(:version).returns("3.1.3")
+      @interface.expects(:ver).returns("foo")
+      @instance.load_interface_attribute(:ver, @interface)
+    end
+
+    should "use the getter specified if exists" do
+      key = :foo2
+      @interface.expects(:get_foo).returns(:bar)
+      @instance.expects(:write_attribute).with(key, :bar)
+      @instance.load_interface_attribute(key, @interface)
+    end
+
+    should "use the property specified first" do
+      key = :foo3
+      @interface.expects(:grab_foo3).returns(:bar)
+      @instance.expects(:write_attribute).with(key, :bar)
+      @instance.load_interface_attribute(key, @interface)
+    end
+
+    should "use the attribute name if no getter is specified" do
+      key = :foo
+      @interface.expects(:foo).returns(:bar)
+      @instance.expects(:write_attribute).with(key, :bar)
+      @instance.load_interface_attribute(key, @interface)
+    end
+
+    should "write the attribute with the value of the proc" do
+      key = :foo
+      @instance.expects(:write_attribute).with(key, "foo").once
+      @instance.load_interface_attribute(key, @interface)
+    end
+  end
+
+  context "saving a single interface attribute" do
+    setup do
+      @instance = InterfaceAttributeModel.new
+      @interface = mock("interface")
+
+      @value = :bar
+      @instance.stubs(:read_attribute).with(anything).returns(@value)
+    end
+
+    should "return immediately if not a valid attribute" do
+      @proc.expects(:call).never
+      @instance.save_interface_attribute(:baz, @interface)
+    end
+
+    should "return immediately if attribute doesn't have an interface setter" do
+      @proc.expects(:call).never
+      @instance.save_interface_attribute(:bar, @interface)
+    end
+
+    should "return immediately if version mismatch" do
+      VirtualBox.stubs(:version).returns("3.2.4")
+      @interface.expects(:ver).never
+      @instance.save_interface_attribute(:ver, @interface)
+    end
+
+    should "load the attribute if version matches" do
+      VirtualBox.stubs(:version).returns("3.1.3")
+      @interface.expects(:ver=)
+      @instance.save_interface_attribute(:ver, @interface)
+    end
+
+    should "save the attribute with the value of the proc" do
+      key = :foo
+      @interface.expects(:foo=).with(@value).once
+      @instance.save_interface_attribute(key, @interface)
+    end
+
+    should "use the property specified first" do
+      key = :foo4
+      @interface.expects(:put_foo4).returns(:bar)
+      @instance.save_interface_attribute(key, @interface)
+    end
+
+    should "use the setter if it exists" do
+      key = :foo2
+      @interface.expects(:set_foo).with(@value).once
+      @instance.save_interface_attribute(key, @interface)
+    end
+
+    should "not save readonly attributes" do
+      key = :foo3
+      @interface.expects(:foo3=).never
+      @instance.save_interface_attribute(key, @interface)
+    end
+  end
+
+  context "loading all interface attributes" do
+    setup do
+      @instance = InterfaceAttributeModel.new
+      @interface = mock('interface')
+    end
+
+    should "load each" do
+      load_seq = sequence("load_seq")
+      InterfaceAttributeModel.attributes.each do |key, options|
+        @instance.expects(:load_interface_attribute).with(key, @interface)
+      end
+
+      @instance.load_interface_attributes(@interface)
+    end
+  end
+
+  context "saving all interface attributes" do
+    setup do
+      @instance = InterfaceAttributeModel.new
+      @interface = mock('interface')
+    end
+
+    should "save each" do
+      InterfaceAttributeModel.attributes.each do |key, options|
+        @instance.expects(:save_interface_attribute).with(key, @interface)
+      end
+
+      @instance.save_interface_attributes(@interface)
+    end
+  end
+end