fog-core 1.24.0 → 1.25.0

data/spec/fake_app/models/collection.rb

@@ -0,0 +1,5 @@
+require File.join(File.dirname(__FILE__), "model")
+
+class Collection < Fog::Collection
+  model Model
+end

data/spec/fake_app/models/model.rb

@@ -0,0 +1,2 @@
+class Model < Fog::Model
+end

data/spec/fake_app/requests/request.rb

@@ -0,0 +1,11 @@
+class FakeService < Fog::Service
+  class Real
+    def request
+    end
+  end
+
+  class Mock
+    def request
+    end
+  end
+end

data/spec/fog_attribute_spec.rb

@@ -1,28 +1,5 @@
-require 'spec_helper'
-require 'xmlrpc/datetime'
-
-class FogAttributeTestModel < Fog::Model
-  identity  :id
-  attribute :key, :aliases => "keys", :squash => "id"
-  attribute :time, :type => :time
-  attribute :bool, :type => :boolean
-  attribute :float, :type => :float
-  attribute :integer, :type => :integer
-  attribute :string, :type => :string
-  attribute :timestamp, :type => :timestamp
-  attribute :array, :type => :array
-  attribute :default, :default => 'default_value', :aliases => :some_name
-  attribute :another_default, :default => false
-
-  has_one :one_object, :single_associations
-  has_many :many_objects, :multiple_associations
-  has_one_identity :one_identity, :single_associations
-  has_many_identities :many_identities, :multiple_associations
-
-  def service
-    Service.new
-  end
-end
+require "spec_helper"
+require "xmlrpc/datetime"
 
 class Service
   def single_associations
@@ -34,30 +11,57 @@ class Service
   end
 end
 
+class FogSingleAssociationModel < Fog::Model
+  identity  :id
+  attribute :name,  :type => :string
+end
+
+class FogMultipleAssociationsModel < Fog::Model
+  identity  :id
+  attribute :name,  :type => :string
+end
+
 class FogSingleAssociationCollection
   def get(id)
     FogSingleAssociationModel.new(:id => id)
   end
 end
 
-class FogMultipleAssociationsCollection
+class FogMultipleAssociationsCollection < Fog::Association
+  model FogMultipleAssociationsModel
+
   def get(id)
     FogMultipleAssociationsModel.new(:id => id)
   end
 end
 
-class FogSingleAssociationModel < Fog::Model
+class FogAttributeTestModel < Fog::Model
   identity  :id
-  attribute :name,  :type => :string
-end
+  attribute :key, :aliases => "keys", :squash => "id"
+  attribute :time, :type => :time
+  attribute :bool, :type => :boolean
+  attribute :float, :type => :float
+  attribute :integer, :type => :integer
+  attribute :string, :type => :string
+  attribute :timestamp, :type => :timestamp
+  attribute :array, :type => :array
+  attribute :default, :default => "default_value", :aliases => :some_name
+  attribute :another_default, :default => false
+  attribute :good_name, :as => :Badname
 
-class FogMultipleAssociationsModel < Fog::Model
-  identity  :id
-  attribute :name,  :type => :string
+  has_one :one_object, :single_associations, :aliases => :single
+  has_many :many_objects, :multiple_associations
+  has_many :objects, :multiple_associations, :association_class => FogMultipleAssociationsCollection
+  has_one_identity :one_identity, :single_associations, :as => :Crazyname
+  has_many_identities :many_identities, :multiple_associations, :aliases => :multiple
+  has_many_identities :identities, :multiple_associations, :association_class => FogMultipleAssociationsCollection
+
+  def service
+    Service.new
+  end
 end
 
 describe "Fog::Attributes" do
-
   let(:model) { FogAttributeTestModel.new }
 
   it "should not create alias for nil" do
@@ -66,12 +70,12 @@ describe "Fog::Attributes" do
 
   describe "squash 'id'" do
     it "squashes if the key is a String" do
-      model.merge_attributes("keys" => {:id => "value"})
-      assert_equal"value", model.key
+      model.merge_attributes("keys" => { :id => "value" })
+      assert_equal "value", model.key
     end
 
     it "squashes if the key is a Symbol" do
-      model.merge_attributes("keys" => {"id" => "value"})
+      model.merge_attributes("keys" => { "id" => "value" })
       assert_equal "value", model.key
     end
   end
@@ -134,7 +138,7 @@ describe "Fog::Attributes" do
     end
 
     it "returns a string as float" do
-      model.merge_attributes(:float => '1')
+      model.merge_attributes(:float => "1")
       assert_in_delta 1.0, model.float
     end
   end
@@ -146,7 +150,7 @@ describe "Fog::Attributes" do
     end
 
     it "returns a string as integer" do
-      model.merge_attributes(:integer => '1')
+      model.merge_attributes(:integer => "1")
       assert_in_delta 1, model.integer
     end
   end
@@ -154,31 +158,31 @@ describe "Fog::Attributes" do
   describe ":type => :string" do
     it "returns a float as string" do
       model.merge_attributes(:string => 1.5)
-      assert_equal '1.5', model.string
+      assert_equal "1.5", model.string
     end
 
     it "returns a integer as string" do
       model.merge_attributes(:string => 1)
-      assert_equal '1', model.string
+      assert_equal "1", model.string
     end
   end
 
   describe ":type => :timestamp" do
     it "returns a date as time" do
       model.merge_attributes(:timestamp => Date.new(2008, 10, 12))
-      assert_equal '2008-10-12 00:00', model.timestamp.strftime('%Y-%m-%d %M:%S')
+      assert_equal "2008-10-12 00:00", model.timestamp.strftime("%Y-%m-%d %M:%S")
       assert_instance_of Fog::Time, model.timestamp
     end
 
     it "returns a time as time" do
       model.merge_attributes(:timestamp => Time.mktime(2007, 11, 1, 15, 25))
-      assert_equal '2007-11-01 25:00', model.timestamp.strftime('%Y-%m-%d %M:%S')
+      assert_equal "2007-11-01 25:00", model.timestamp.strftime("%Y-%m-%d %M:%S")
       assert_instance_of Fog::Time, model.timestamp
     end
 
     it "returns a date_time as time" do
       model.merge_attributes(:timestamp => DateTime.new(2007, 11, 1, 15, 25, 0))
-      assert_equal '2007-11-01 25:00', model.timestamp.strftime('%Y-%m-%d %M:%S')
+      assert_equal "2007-11-01 25:00", model.timestamp.strftime("%Y-%m-%d %M:%S")
       assert_instance_of Fog::Time, model.timestamp
     end
   end
@@ -205,12 +209,12 @@ describe "Fog::Attributes" do
 
     it "returns a single element as array" do
       model.merge_attributes(:array => 1.5)
-      assert_equal [ 1.5 ], model.array
+      assert_equal [1.5], model.array
     end
 
     it "returns an array as array" do
-      model.merge_attributes(:array => [ 1, 2 ])
-      assert_equal [ 1, 2 ], model.array
+      model.merge_attributes(:array => [1, 2])
+      assert_equal [1, 2], model.array
     end
   end
 
@@ -220,17 +224,17 @@ describe "Fog::Attributes" do
     end
 
     it "should return the value of the object when default is not defined" do
-      model.merge_attributes({ :bool => false })
+      model.merge_attributes(:bool => false)
       assert_equal model.bool, false
     end
 
     it "should return the default value on a new object with value equal nil" do
-      assert_equal model.default, 'default_value'
+      assert_equal model.default, "default_value"
     end
 
     it "should return the value on a new object with value not equal nil" do
-      model.default = 'not default'
-      assert_equal model.default, 'not default'
+      model.default = "not default"
+      assert_equal model.default, "not default"
     end
 
     it "should return false when default value is false on a new object" do
@@ -238,12 +242,12 @@ describe "Fog::Attributes" do
     end
 
     it "should return the value of the persisted object" do
-      model.merge_attributes({ :id => 'some-crazy-id', :default => 23 })
+      model.merge_attributes(:id => "some-crazy-id", :default => 23)
       assert_equal model.default, 23
     end
 
     it "should return nil on a persisted object without a value" do
-      model.merge_attributes({ :id => 'some-crazy-id' })
+      model.merge_attributes(:id => "some-crazy-id")
       assert_equal model.default, nil
     end
 
@@ -259,14 +263,19 @@ describe "Fog::Attributes" do
     end
 
     it "should create a getter to save the association model" do
-      model.merge_attributes(:one_object => FogSingleAssociationModel.new(:id => '123'))
+      model.merge_attributes(:one_object => FogSingleAssociationModel.new(:id => "123"))
       assert_instance_of FogSingleAssociationModel, model.one_object
-      assert_equal model.one_object.attributes, { :id => '123' }
+      assert_equal model.one_object.attributes, :id => "123"
     end
 
     it "should create a setter that accept an object as param" do
-      model.one_object = FogSingleAssociationModel.new(:id => '123')
-      assert_equal model.one_object.attributes, { :id => '123' }
+      model.one_object = FogSingleAssociationModel.new(:id => "123")
+      assert_equal model.one_object.attributes, :id => "123"
+    end
+
+    it "should create an alias to single" do
+      model.merge_attributes(:single => FogSingleAssociationModel.new(:id => "123"))
+      assert_equal model.one_object.attributes, :id => "123"
     end
   end
 
@@ -276,65 +285,94 @@ describe "Fog::Attributes" do
     end
 
     it "should create a getter to load the association model" do
-      model.merge_attributes(:one_identity => '123')
+      model.merge_attributes(:one_identity => "123")
       assert_instance_of FogSingleAssociationModel, model.one_identity
-      assert_equal model.one_identity.attributes, { :id => '123' }
+      assert_equal model.one_identity.attributes, :id => "123"
     end
 
     describe "should create a setter that accept" do
       it "an id as param" do
-        model.one_identity = '123'
-        assert_equal model.one_identity.attributes, { :id => '123' }
+        model.one_identity = "123"
+        assert_equal model.one_identity.attributes, :id => "123"
       end
 
       it "a model as param" do
-        model.one_identity = FogSingleAssociationModel.new(:id => '123')
-        assert_equal model.one_identity.attributes, { :id => '123' }
+        model.one_identity = FogSingleAssociationModel.new(:id => "123")
+        assert_equal model.one_identity.attributes, :id => "123"
       end
     end
   end
 
   describe ".has_many" do
+    it "should return an instance of Fog::Association" do
+      model.many_objects = [FogMultipleAssociationsModel.new(:id => "456")]
+      assert_instance_of Fog::Association, model.many_objects
+    end
+
     it "should create an instance_variable to save the associated objects" do
       assert_equal model.many_objects, []
     end
 
     it "should create a getter to save all associated models" do
-      model.merge_attributes(:many_objects => [ FogMultipleAssociationsModel.new(:id => '456') ])
-      assert_instance_of Array, model.many_objects
+      model.merge_attributes(:many_objects => [FogMultipleAssociationsModel.new(:id => "456")])
+      assert_instance_of Fog::Association, model.many_objects
       assert_equal model.many_objects.size, 1
       assert_instance_of FogMultipleAssociationsModel, model.many_objects.first
-      assert_equal model.many_objects.first.attributes, { :id => '456' }
+      assert_equal model.many_objects.first.attributes, :id => "456"
     end
 
     it "should create a setter that accept an array of objects as param" do
-      model.many_objects = [ FogMultipleAssociationsModel.new(:id => '456') ]
-      assert_equal model.many_objects.first.attributes, { :id => '456' }
+      model.many_objects = [FogMultipleAssociationsModel.new(:id => "456")]
+      assert_equal model.many_objects.first.attributes, :id => "456"
+    end
+
+    describe "with a custom collection class" do
+      it "should return an instance of that collection class" do
+        model.objects = [FogMultipleAssociationsModel.new(:id => "456")]
+        assert_instance_of FogMultipleAssociationsCollection, model.objects
+      end
     end
   end
 
   describe ".has_many_identities" do
+    it "should return an instance of Fog::Association" do
+      model.many_identities = ["456"]
+      assert_instance_of Fog::Association, model.many_identities
+    end
+
     it "should create an instance_variable to save the associations identities" do
       assert_equal model.many_identities, []
     end
 
     it "should create a getter to load all association models" do
-      model.merge_attributes(:many_identities => [ '456' ])
-      assert_instance_of Array, model.many_identities
+      model.merge_attributes(:many_identities => ["456"])
+      assert_instance_of Fog::Association, model.many_identities
       assert_equal model.many_identities.size, 1
       assert_instance_of FogMultipleAssociationsModel, model.many_identities.first
-      assert_equal model.many_identities.first.attributes, { :id => '456' }
+      assert_equal model.many_identities.first.attributes, :id => "456"
     end
 
     describe "should create a setter that accept an array of" do
       it "ids as param" do
-        model.many_identities = [ '456' ]
-        assert_equal model.many_identities.first.attributes, { :id => '456' }
+        model.many_identities = ["456"]
+        assert_equal model.many_identities.first.attributes, :id => "456"
       end
 
       it "models as param" do
-        model.many_identities = [ FogMultipleAssociationsModel.new(:id => '456') ]
-        assert_equal model.many_identities.first.attributes, { :id => '456' }
+        model.many_identities = [FogMultipleAssociationsModel.new(:id => "456")]
+        assert_equal model.many_identities.first.attributes, :id => "456"
+      end
+    end
+
+    it "should create an alias to multiple" do
+      model.merge_attributes(:multiple => ["456"])
+      assert_equal model.many_identities.first.attributes, :id => "456"
+    end
+
+    describe "with a custom collection class" do
+      it "should return an instance of that collection class" do
+        model.identities = ["456"]
+        assert_instance_of FogMultipleAssociationsCollection, model.identities
       end
     end
   end
@@ -342,37 +380,39 @@ describe "Fog::Attributes" do
   describe "#all_attributes" do
     describe "on a persisted object" do
       it "should return all attributes without default values" do
-        model.merge_attributes( :id => 2, :float => 3.2, :integer => 55555555 )
+        model.merge_attributes(:id => 2, :float => 3.2, :integer => 55_555_555)
         assert model.persisted?
-        assert_equal model.all_attributes, { :id => 2,
+        assert_equal model.all_attributes,   :id => 2,
                                              :key => nil,
                                              :time => nil,
                                              :bool => nil,
                                              :float => 3.2,
-                                             :integer => 55555555,
+                                             :integer => 55_555_555,
                                              :string => nil,
                                              :timestamp => nil,
                                              :array => [],
                                              :default => nil,
-                                             :another_default => nil }
+                                             :another_default => nil,
+                                             :Badname => nil
       end
     end
 
     describe "on a new object" do
       it "should return all attributes including default values for empty attributes" do
-        model.merge_attributes( :float => 3.2, :integer => 55555555 )
+        model.merge_attributes(:float => 3.2, :integer => 55_555_555)
         refute model.persisted?
-        assert_equal model.all_attributes, { :id => nil,
+        assert_equal model.all_attributes,   :id => nil,
                                              :key => nil,
                                              :time => nil,
                                              :bool => nil,
                                              :float => 3.2,
-                                             :integer => 55555555,
+                                             :integer => 55_555_555,
                                              :string => nil,
                                              :timestamp => nil,
                                              :array => [],
-                                             :default => 'default_value',
-                                             :another_default => false }
+                                             :default => "default_value",
+                                             :another_default => false,
+                                             :Badname => nil
       end
     end
   end
@@ -380,23 +420,27 @@ describe "Fog::Attributes" do
   describe "#all_associations" do
     describe "without any association" do
       it "should return all associations empty" do
-        assert_equal model.all_associations, { :one_object => nil,
-                                               :many_objects => [],
-                                               :one_identity => nil,
-                                               :many_identities => [] }
+        assert_equal model.all_associations, :one_object => nil,
+                                             :many_objects => [],
+                                             :Crazyname => nil,
+                                             :many_identities => [],
+                                             :objects => [],
+                                             :identities => []
       end
     end
 
     describe "with associations" do
       it "should return all association objects" do
         @one_object = FogMultipleAssociationsModel.new
-        @many_objects = [ @one_object ]
+        @many_objects = [@one_object]
         model.merge_attributes(:one_object => @one_object, :many_objects => @many_objects)
-        model.merge_attributes(:one_identity => 'XYZ', :many_identities => %w(ABC))
-        assert_equal model.all_associations, { :one_object => @one_object,
+        model.merge_attributes(:one_identity => "XYZ", :many_identities => %w(ABC))
+        assert_equal model.all_associations,   :one_object => @one_object,
                                                :many_objects => @many_objects,
-                                               :one_identity => 'XYZ',
-                                               :many_identities => %w(ABC) }
+                                               :Crazyname => "XYZ",
+                                               :many_identities => %w(ABC),
+                                               :objects => [],
+                                               :identities => []
       end
     end
   end
@@ -405,61 +449,59 @@ describe "Fog::Attributes" do
     describe "on a persisted object" do
       it "should return all association and attributes but no default values" do
         @one_object = FogMultipleAssociationsModel.new
-        @many_objects = [ @one_object ]
-        model.merge_attributes(:id => 2, :float => 3.2, :integer => 55555555)
+        @many_objects = [@one_object]
+        model.merge_attributes(:id => 2, :float => 3.2, :integer => 55_555_555)
         model.merge_attributes(:one_object => @one_object, :many_objects => @many_objects)
-        model.merge_attributes(:one_identity => 'XYZ', :many_identities => %w(ABC))
+        model.merge_attributes(:one_identity => "XYZ", :many_identities => %w(ABC))
         assert model.persisted?
-        assert_equal model.all_associations_and_attributes, { :id => 2,
-                                         :key => nil,
-                                         :time => nil,
-                                         :bool => nil,
-                                         :float => 3.2,
-                                         :integer => 55555555,
-                                         :string => nil,
-                                         :timestamp => nil,
-                                         :array => [],
-                                         :default => nil,
-                                         :another_default => nil,
-                                         :one_object => @one_object,
-                                         :many_objects => @many_objects,
-                                         :one_identity => 'XYZ',
-                                         :many_identities => %w(ABC) }
+        assert_equal model.all_associations_and_attributes,  :id => 2,
+                                                             :key => nil,
+                                                             :time => nil,
+                                                             :bool => nil,
+                                                             :float => 3.2,
+                                                             :integer => 55_555_555,
+                                                             :string => nil,
+                                                             :timestamp => nil,
+                                                             :array => [],
+                                                             :default => nil,
+                                                             :another_default => nil,
+                                                             :Badname => nil,
+                                                             :one_object => @one_object,
+                                                             :many_objects => @many_objects,
+                                                             :objects => [],
+                                                             :identities => [],
+                                                             :Crazyname => "XYZ",
+                                                             :many_identities => %w(ABC)
       end
     end
 
     describe "on a non persisted object" do
       it "should return all association and attributes and the default value for blank attributes" do
         @one_object = FogMultipleAssociationsModel.new
-        @many_objects = [ @one_object ]
-        model.merge_attributes(:float => 3.2, :integer => 55555555)
+        @many_objects = [@one_object]
+        model.merge_attributes(:float => 3.2, :integer => 55_555_555)
         model.merge_attributes(:one_object => @one_object, :many_objects => @many_objects)
-        model.merge_attributes(:one_identity => 'XYZ', :many_identities => %w(ABC))
+        model.merge_attributes(:one_identity => "XYZ", :many_identities => %w(ABC))
         refute model.persisted?
-        assert_equal model.all_associations_and_attributes, { :id => nil,
-                                         :key => nil,
-                                         :time => nil,
-                                         :bool => nil,
-                                         :float => 3.2,
-                                         :integer => 55555555,
-                                         :string => nil,
-                                         :timestamp => nil,
-                                         :array => [],
-                                         :default => 'default_value',
-                                         :another_default => false,
-                                         :one_object => @one_object,
-                                         :many_objects => @many_objects,
-                                         :one_identity => 'XYZ',
-                                         :many_identities => %w(ABC) }
+        assert_equal model.all_associations_and_attributes,  :id => nil,
+                                                             :key => nil,
+                                                             :time => nil,
+                                                             :bool => nil,
+                                                             :float => 3.2,
+                                                             :integer => 55_555_555,
+                                                             :string => nil,
+                                                             :timestamp => nil,
+                                                             :array => [],
+                                                             :default => "default_value",
+                                                             :another_default => false,
+                                                             :Badname => nil,
+                                                             :one_object => @one_object,
+                                                             :many_objects => @many_objects,
+                                                             :objects => [],
+                                                             :identities => [],
+                                                             :Crazyname => "XYZ",
+                                                             :many_identities => %w(ABC)
       end
     end
   end
-
-  describe "aliases accessors" do
-    it "should have accessors to the original attribute" do
-      model.merge_attributes(:default => true)
-      assert model.respond_to?(:some_name)
-      assert model.some_name
-    end
-  end
 end