virtualbox 0.4.1 → 0.4.2

data/test/virtualbox/abstract_model/dirty_test.rb

@@ -3,38 +3,38 @@ 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"
@@ -42,7 +42,7 @@ class DirtyTest < Test::Unit::TestCase
       @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"
@@ -50,7 +50,7 @@ class DirtyTest < Test::Unit::TestCase
       @model.clear_dirty!
       assert !@model.changed?
     end
-    
+
     should "show changes on specific field" do
       assert !@model.changed?
       @model.foo = "my value"
@@ -58,24 +58,24 @@ class DirtyTest < Test::Unit::TestCase
       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

data/test/virtualbox/abstract_model/relatable_test.rb

@@ -10,120 +10,120 @@ class RelatableTest < Test::Unit::TestCase
     def self.set_relationship(caller, old_value, new_value)
     end
   end
-  
+
   class RelatableModel
     include VirtualBox::AbstractModel::Relatable
-    
+
     relationship :foos, Relatee
     relationship :bars, BarRelatee
   end
-  
+
   setup do
     @data = {}
   end
-  
+
   context "class methods" do
     should "read back relationships in order added" do
       order = mock("order")
       order_seq = sequence("order_seq")
       order.expects(:foos).in_sequence(order_seq)
       order.expects(:bars).in_sequence(order_seq)
-      
+
       RelatableModel.relationships.each do |name, options|
         order.send(name)
       end
     end
   end
-  
+
   context "setting a relationship" do
     setup do
       @model = RelatableModel.new
     end
-    
+
     should "have a magic method relationship= which calls set_relationship" do
       @model.expects(:set_relationship).with(:foos, "FOOS!")
       @model.foos = "FOOS!"
     end
-    
+
     should "raise a NonSettableRelationshipException if relationship can't be set" do
       assert_raises(VirtualBox::Exceptions::NonSettableRelationshipException) {
         @model.foos = "FOOS!"
       }
     end
-    
+
     should "call set_relationship on the relationship class" do
       BarRelatee.expects(:populate_relationship).returns("foo")
       @model.populate_relationships({})
-      
+
       BarRelatee.expects(:set_relationship).with(@model, "foo", "bars")
       assert_nothing_raised { @model.bars = "bars" }
     end
-    
+
     should "set the result of set_relationship as the new relationship data" do
       BarRelatee.stubs(:set_relationship).returns("hello")
       @model.bars = "zoo"
       assert_equal "hello", @model.bars
     end
   end
-  
+
   context "subclasses" do
     class SubRelatableModel < RelatableModel
       relationship :bars, RelatableTest::Relatee
     end
-    
+
     setup do
       @relationships = SubRelatableModel.relationships
     end
-    
+
     should "inherit relationships of parent" do
       assert SubRelatableModel.has_relationship?(:foos)
       assert SubRelatableModel.has_relationship?(:bars)
     end
-    
+
     should "inherit options of relationships" do
       assert_equal Relatee, SubRelatableModel.relationships_hash[: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)
@@ -135,69 +135,69 @@ class RelatableTest < Test::Unit::TestCase
         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 "checking for relationships" do
     setup do
       @model = RelatableModel.new
     end
-    
+
     should "have a class method as well" do
       assert RelatableModel.has_relationship?(:foos)
       assert !RelatableModel.has_relationship?(:bazs)
     end
-    
+
     should "return true for existing relationships" do
       assert @model.has_relationship?(:foos)
     end
-    
+
     should "return false for nonexistent relationships" do
       assert !@model.has_relationship?(:bazs)
     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)

data/test/virtualbox/abstract_model/validatable_test.rb

@@ -3,27 +3,27 @@ require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
 class ValidatableTest < Test::Unit::TestCase
   class ValidatableModel
     include VirtualBox::AbstractModel::Validatable
-    
+
     attr_accessor :foos
     attr_accessor :bars
   end
-  
+
   context "errors" do
     setup do
       @model = ValidatableModel.new
     end
-  
+
     should "have no errors by default" do
       assert @model.errors.empty?
     end
-    
+
     should "be able to add errors" do
       @model.add_error(:foo, "is blank")
       assert !@model.errors.empty?
       assert !@model.errors[:foo].nil?
       assert_equal "is blank", @model.errors[:foo].first
     end
-    
+
     should "be able to add multiple errors" do
       @model.add_error(:foo, "foo")
       @model.add_error(:foo, "bar")
@@ -31,7 +31,7 @@ class ValidatableTest < Test::Unit::TestCase
       assert !@model.errors[:foo].nil?
       assert_equal 2, @model.errors[:foo].length
     end
-    
+
     should "be able to clear errors" do
       @model.add_error(:foo, "foo")
       assert !@model.errors.empty?
@@ -39,82 +39,82 @@ class ValidatableTest < Test::Unit::TestCase
       assert @model.errors.empty?
     end
   end
-  
+
   context "validity" do
     setup do
       @model = ValidatableModel.new
     end
-    
+
     should "call validate on valid?" do
       @model.expects(:validate)
       assert @model.valid?
     end
-    
+
     should "be valid if there are no errors" do
       assert @model.valid?
     end
-    
+
     should "be invalid if there are any errors" do
       @model.add_error(:foo, "foo")
       assert !@model.valid?
     end
-    
+
     should "have a validate method by default which returns true" do
       assert @model.validate
     end
   end
-  
+
   context "specific validations" do
     setup do
       @model = ValidatableModel.new
     end
-    
+
     context "validates_presence_of" do
       setup do
         @model.foos = "foo"
         @model.bars = "bar"
       end
-      
+
       should "not add an error if not blank" do
         @model.validates_presence_of(:foos)
         assert @model.valid?
       end
-      
+
       should "add an error if blank field" do
         @model.foos = ""
         @model.validates_presence_of(:foos)
         assert !@model.valid?
       end
-      
+
       should "add an error for a nil field" do
         @model.foos = nil
         @model.validates_presence_of(:foos)
         assert !@model.valid?
       end
-      
+
       should "validate multiple fields" do
         @model.bars = nil
         @model.validates_presence_of([:foos, :bars])
-        
+
         assert !@model.valid?
         assert @model.errors[:bars]
       end
-      
+
       should "return false on invalid" do
         @model.bars =  nil
         assert !@model.validates_presence_of(:bars)
       end
-      
+
       should "return true on valid" do
         @model.bars = "foo"
         assert @model.validates_presence_of(:bars)
       end
-      
+
       should "return false if any are invalid on multiple fields" do
         @model.bars = nil
         assert !@model.validates_presence_of([:foos, :bars])
       end
-      
+
       should "return true if all fields are valid" do
         @model.foos = "foo"
         @model.bars = "bar"