hydra_attribute 0.4.2 → 0.5.0.rc1

data/spec/hydra_attribute/hydra_attribute_spec.rb

@@ -1,19 +1,217 @@
 require 'spec_helper'
 
 describe HydraAttribute::HydraAttribute do
-  describe '#hydra_sets=' do
-    let!(:hydra_attribute) { Product.hydra_attributes.create(name: 'one', backend_type: 'string') }
+  describe '.all_by_entity_type' do
+    describe 'hydra_attributes table has several records' do
+      let!(:attr_id1) { ::ActiveRecord::Base.connection.insert(%q[INSERT INTO hydra_attributes(entity_type, name, backend_type, created_at, updated_at) VALUES('Product', 'attr1', 'string', '2012-12-12', '2012-12-12')])  }
+      let!(:attr_id2) { ::ActiveRecord::Base.connection.insert(%q[INSERT INTO hydra_attributes(entity_type, name, backend_type, created_at, updated_at) VALUES('Product', 'attr2', 'integer', '2012-12-12', '2012-12-12')]) }
+      let!(:attr_id3) { ::ActiveRecord::Base.connection.insert(%q[INSERT INTO hydra_attributes(entity_type, name, backend_type, created_at, updated_at) VALUES('Category', 'attr3', 'string', '2012-12-12', '2012-12-12')]) }
 
-    it 'should clear entity cache if assign hydra sets collection' do
-      hydra_set = Product.hydra_sets.create(name: 'Default')
-      Product.should_receive(:clear_hydra_method_cache!)
-      hydra_attribute.hydra_sets = [hydra_set]
+      it 'should return hydra_attributes which have the following entity_type' do
+        HydraAttribute::HydraAttribute.all_by_entity_type('Product').map(&:name).should =~ %w[attr1 attr2]
+        HydraAttribute::HydraAttribute.all_by_entity_type('Category').map(&:name).should =~ %w[attr3]
+      end
+
+      it 'should not return hydra_attribute which was removed in runtime' do
+        HydraAttribute::HydraAttribute.find(attr_id1).destroy
+        HydraAttribute::HydraAttribute.all_by_entity_type('Product').map(&:name).should =~ %w[attr2]
+        HydraAttribute::HydraAttribute.all_by_entity_type('Category').map(&:name).should =~ %w[attr3]
+      end
+
+      it 'should not return hydra_attribute which entity_type was changed in runtime' do
+        hydra_attribute = HydraAttribute::HydraAttribute.find(attr_id1)
+        hydra_attribute.entity_type = 'Category'
+        hydra_attribute.save
+
+        HydraAttribute::HydraAttribute.all_by_entity_type('Product').map(&:name).should =~ %w[attr2]
+        HydraAttribute::HydraAttribute.all_by_entity_type('Category').map(&:name).should =~ %w[attr1 attr3]
+      end
+    end
+
+    describe 'hydra_attributes table is blank' do
+      it 'should return blank collection' do
+        HydraAttribute::HydraAttribute.all_by_entity_type('Product').should == []
+      end
+
+      it 'should return hydra_attribute which was created in runtime' do
+        HydraAttribute::HydraAttribute.all_by_entity_type('Product').should == []
+        hydra_attribute = HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'attr1', backend_type: 'string')
+        HydraAttribute::HydraAttribute.all_by_entity_type('Product').should == [hydra_attribute]
+      end
+    end
+  end
+
+  describe '.ids_by_entity_type' do
+    describe 'hydra_attributes table has several records' do
+      let!(:attr_id1) { ::ActiveRecord::Base.connection.insert(%q[INSERT INTO hydra_attributes(entity_type, name, backend_type, created_at, updated_at) VALUES('Product', 'attr1', 'string', '2012-12-12', '2012-12-12')]).to_i  }
+      let!(:attr_id2) { ::ActiveRecord::Base.connection.insert(%q[INSERT INTO hydra_attributes(entity_type, name, backend_type, created_at, updated_at) VALUES('Product', 'attr2', 'integer', '2012-12-12', '2012-12-12')]).to_i }
+      let!(:attr_id3) { ::ActiveRecord::Base.connection.insert(%q[INSERT INTO hydra_attributes(entity_type, name, backend_type, created_at, updated_at) VALUES('Category', 'attr3', 'string', '2012-12-12', '2012-12-12')]).to_i }
+
+      it 'should return IDs by entity_type' do
+        HydraAttribute::HydraAttribute.ids_by_entity_type('Product').should  =~ [attr_id1, attr_id2]
+        HydraAttribute::HydraAttribute.ids_by_entity_type('Category').should =~ [attr_id3]
+      end
+
+      it 'should not return ID if model was removed in runtime' do
+        HydraAttribute::HydraAttribute.find(attr_id1).destroy
+        HydraAttribute::HydraAttribute.ids_by_entity_type('Product').should  =~ [attr_id2]
+        HydraAttribute::HydraAttribute.ids_by_entity_type('Category').should =~ [attr_id3]
+      end
+
+      it 'should not return ID if entity_type was updated in runtime' do
+        hydra_attribute = HydraAttribute::HydraAttribute.find(attr_id1)
+        hydra_attribute.entity_type = 'Category'
+        hydra_attribute.save
+
+        HydraAttribute::HydraAttribute.ids_by_entity_type('Product').should  =~ [attr_id2]
+        HydraAttribute::HydraAttribute.ids_by_entity_type('Category').should =~ [attr_id1, attr_id3]
+      end
+    end
+
+    describe 'hydra_attributes table is blank' do
+      it 'should return blank collection' do
+        HydraAttribute::HydraAttribute.ids_by_entity_type('Product').should == []
+      end
+
+      it 'should return IDs which were created in runtime' do
+        a1 = HydraAttribute::HydraAttribute.create(entity_type: 'Product',  name: 'attr', backend_type: 'string')
+        a2 = HydraAttribute::HydraAttribute.create(entity_type: 'Category', name: 'attr', backend_type: 'string')
+
+        HydraAttribute::HydraAttribute.ids_by_entity_type('Product').should  == [a1.id]
+        HydraAttribute::HydraAttribute.ids_by_entity_type('Category').should == [a2.id]
+      end
+    end
+  end
+
+  describe '.names_by_entity_type' do
+    describe 'hydra_attributes table has several records' do
+      let!(:attr_id1) { ::ActiveRecord::Base.connection.insert(%q[INSERT INTO hydra_attributes(entity_type, name, backend_type, created_at, updated_at) VALUES('Product', 'attr1', 'string', '2012-12-12', '2012-12-12')])  }
+      let!(:attr_id2) { ::ActiveRecord::Base.connection.insert(%q[INSERT INTO hydra_attributes(entity_type, name, backend_type, created_at, updated_at) VALUES('Product', 'attr2', 'integer', '2012-12-12', '2012-12-12')]) }
+      let!(:attr_id3) { ::ActiveRecord::Base.connection.insert(%q[INSERT INTO hydra_attributes(entity_type, name, backend_type, created_at, updated_at) VALUES('Category', 'attr3', 'string', '2012-12-12', '2012-12-12')]) }
+
+      it 'should return names by entity_type' do
+        HydraAttribute::HydraAttribute.names_by_entity_type('Product').should  =~ %w[attr1 attr2]
+        HydraAttribute::HydraAttribute.names_by_entity_type('Category').should =~ %w[attr3]
+      end
+
+      it 'should not return name for model which was removed in runtime' do
+        HydraAttribute::HydraAttribute.find(attr_id1).destroy
+        HydraAttribute::HydraAttribute.names_by_entity_type('Product').should  =~ %w[attr2]
+        HydraAttribute::HydraAttribute.names_by_entity_type('Category').should =~ %w[attr3]
+      end
+
+      it 'should not return name for model which entity_type was changed in runtime' do
+        hydra_attribute = HydraAttribute::HydraAttribute.find(attr_id1)
+        hydra_attribute.entity_type = 'Category'
+        hydra_attribute.save
+
+        HydraAttribute::HydraAttribute.names_by_entity_type('Product').should  =~ %w[attr2]
+        HydraAttribute::HydraAttribute.names_by_entity_type('Category').should =~ %w[attr1 attr3]
+      end
+
+      it 'should return updated attribute name' do
+        hydra_attribute = HydraAttribute::HydraAttribute.find(attr_id1)
+        hydra_attribute.name = 'new_attr'
+        hydra_attribute.save
+
+        HydraAttribute::HydraAttribute.names_by_entity_type('Product').should  =~ %w[new_attr attr2]
+        HydraAttribute::HydraAttribute.names_by_entity_type('Category').should =~ %w[attr3]
+      end
     end
 
-    it 'should clear entity cache if assign blank collection' do
-      hydra_attribute.hydra_sets.create(name: 'Default')
-      Product.should_receive(:clear_hydra_method_cache!)
-      hydra_attribute.hydra_sets = []
+    describe 'hydra_attributes table is blank' do
+      it 'should return blank collection' do
+        HydraAttribute::HydraAttribute.names_by_entity_type('Product').should == []
+      end
+
+      it 'should return names which where created in runtime' do
+        HydraAttribute::HydraAttribute.create(entity_type: 'Product',  name: 'attr1', backend_type: 'string')
+        HydraAttribute::HydraAttribute.create(entity_type: 'Category', name: 'attr2', backend_type: 'string')
+
+        HydraAttribute::HydraAttribute.names_by_entity_type('Product').should  == %w[attr1]
+        HydraAttribute::HydraAttribute.names_by_entity_type('Category').should == %w[attr2]
+      end
     end
   end
+
+  describe '#hydra_sets' do
+    it 'should return blank array if model has not ID' do
+      HydraAttribute::HydraAttribute.new.should have(0).hydra_sets
+    end
+
+    it 'should return blank array if model has not any hydra_sets' do
+      hydra_attribute = HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'title', backend_type: 'string')
+      hydra_attribute.should have(0).hydra_sets
+    end
+
+    it 'should return array of hydra_sets for the current hydra_attribute' do
+      hydra_attribute1 = HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'attr1', backend_type: 'string')
+      hydra_attribute2 = HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'attr2', backend_type: 'string')
+      hydra_set1       = HydraAttribute::HydraSet.create(entity_type: 'Product', name: 'default1')
+      hydra_set2       = HydraAttribute::HydraSet.create(entity_type: 'Product', name: 'default2')
+      hydra_set3       = HydraAttribute::HydraSet.create(entity_type: 'Product', name: 'default3')
+
+
+      HydraAttribute::HydraAttributeSet.create(hydra_set_id: hydra_set1.id, hydra_attribute_id: hydra_attribute1.id)
+      HydraAttribute::HydraAttributeSet.create(hydra_set_id: hydra_set2.id, hydra_attribute_id: hydra_attribute1.id)
+      HydraAttribute::HydraAttributeSet.create(hydra_set_id: hydra_set3.id, hydra_attribute_id: hydra_attribute2.id)
+
+      hydra_attribute1.should have(2).hydra_sets
+      hydra_attribute2.should have(1).hydra_sets
+
+      hydra_attribute1.hydra_sets.should include(hydra_set1)
+      hydra_attribute1.hydra_sets.should include(hydra_set2)
+      hydra_attribute2.hydra_sets.should include(hydra_set3)
+    end
+  end
+
+  describe 'validations' do
+    it 'should require entity_type' do
+      hydra_attribute = HydraAttribute::HydraAttribute.new
+      hydra_attribute.valid?
+      hydra_attribute.errors.should include(:entity_type)
+
+      hydra_attribute.entity_type = 'Product'
+      hydra_attribute.valid?
+      hydra_attribute.errors.should_not include(:entity_type)
+    end
+
+    it 'should require name' do
+      hydra_attribute = HydraAttribute::HydraAttribute.new
+      hydra_attribute.valid?
+      hydra_attribute.errors.should include(:name)
+
+      hydra_attribute.name = 'price'
+      hydra_attribute.valid?
+      hydra_attribute.errors.should_not include(:price)
+    end
+
+    it 'should have a unique entity_type and name' do
+      HydraAttribute::HydraAttribute.create(name: 'price', entity_type: 'Product', backend_type: 'float').should be_persisted
+      HydraAttribute::HydraAttribute.create(name: 'price', entity_type: 'Product', backend_type: 'float').should_not be_persisted
+    end
+
+    it 'should require backend_type' do
+      hydra_attribute = HydraAttribute::HydraAttribute.new
+      hydra_attribute.valid?
+      hydra_attribute.errors.should include(:backend_type)
+
+      hydra_attribute.backend_type = 'integer'
+      hydra_attribute.valid?
+      hydra_attribute.errors.should_not include(:backend_type)
+    end
+
+    it 'should have a valid backend_type' do
+      hydra_attribute = HydraAttribute::HydraAttribute.new(backend_type: 'fake')
+      hydra_attribute.valid?
+      hydra_attribute.errors.should include(:backend_type)
+
+      HydraAttribute::SUPPORTED_BACKEND_TYPES.each do |backend_type|
+        hydra_attribute.backend_type = backend_type
+        hydra_attribute.valid?
+        hydra_attribute.errors.should_not include(:backend_type)
+      end
+    end
+  end
+
 end

data/spec/hydra_attribute/hydra_entity_attribute_association_spec.rb

@@ -0,0 +1,216 @@
+require 'spec_helper'
+
+describe HydraAttribute::HydraEntityAttributeAssociation do
+  describe '#has_proxy_method?' do
+    let(:association)      { HydraAttribute::HydraEntityAttributeAssociation.new(Product.new) }
+    let!(:hydra_attribute) { HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'code', backend_type: 'string') }
+
+    it 'should return true if hydra_attribute has appropriate attribute for entity type' do
+      [:code, :code=, :code_was, :code_before_type_cast].each do |method|
+        association.should have_proxy_method(method)
+      end
+    end
+
+    it 'should return false if hydra_attribute has not appropriate attribute for entity type' do
+      HydraAttribute::HydraAttribute.create(entity_type: 'Category', name: 'title', backend_type: 'string')
+      [:title, :title=, :title_was, :title_before_type_cast].each do |method|
+        association.should_not have_proxy_method(method)
+      end
+    end
+
+    it 'should correct resolve if new attribute was created in runtime' do
+      [:title, :title=, :title_was, :title_before_type_cast].each do |method|
+        association.should_not have_proxy_method(method)
+      end
+
+      HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'title', backend_type: 'string')
+
+      [:title, :title=, :title_was, :title_before_type_cast].each do |method|
+        association.should have_proxy_method(method)
+      end
+    end
+
+    it 'should correct resolve if attribute name was updated' do
+      [:code, :code=, :code_was, :code_before_type_cast].each do |method|
+        association.should have_proxy_method(method)
+      end
+
+      hydra_attribute.name = 'title'
+      hydra_attribute.save
+
+      [:code, :code=, :code_was, :code_before_type_cast].each do |method|
+        association.should_not have_proxy_method(method)
+      end
+
+      [:title, :title=, :title_was, :title_before_type_cast].each do |method|
+        association.should have_proxy_method(method)
+      end
+    end
+
+    it 'should correct resolve if attribute entity type was updated' do
+      hydra_attribute.entity_type = 'Category'
+      hydra_attribute.save
+
+      category_assoc = HydraAttribute::HydraEntityAttributeAssociation.new(Category.new)
+      [:code, :code=, :code_was, :code_before_type_cast].each do |method|
+        association.should_not have_proxy_method(method)
+        category_assoc.should have_proxy_method(method)
+      end
+    end
+
+    it 'should correct resolve if hydra attribute was deleted' do
+      hydra_attribute.destroy
+      [:code, :code=, :code_was, :code_before_type_cast].each do |method|
+        association.should_not have_proxy_method(method)
+      end
+    end
+  end
+
+  describe '#delegate' do
+    let!(:hydra_attribute1) { HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'color', backend_type: 'string', default_value: 'green') }
+    let!(:hydra_attribute2) { HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'title', backend_type: 'string') }
+    let(:association)       { HydraAttribute::HydraEntityAttributeAssociation.new(Product.new) }
+
+    it 'should correct proxy method to hydra value' do
+      association.delegate(:color).should == 'green'
+      association.delegate(:title).should be_nil
+
+      association.delegate(:color?).should be_true
+      association.delegate(:title?).should be_false
+
+      association.delegate(:color=, 'black')
+      association.delegate(:title=, 'qwerty')
+
+      association.delegate(:color).should == 'black'
+      association.delegate(:title).should == 'qwerty'
+
+      association.delegate(:color?).should be_true
+      association.delegate(:title?).should be_true
+    end
+
+    it 'should raise an error if attribute name is unknown' do
+      lambda do
+        association.delegate(:price)
+      end.should raise_error(HydraAttribute::HydraEntityAttributeAssociation::WrongProxyMethodError, 'Unknown :price method')
+    end
+
+    it 'should raise an error if hydra set does not have attribute' do
+      hydra_set = HydraAttribute::HydraSet.create(entity_type: 'Product', name: 'default')
+      association.entity.hydra_set_id = hydra_set.id
+
+      lambda do
+        association.delegate(:color)
+      end.should raise_error(HydraAttribute::HydraSet::MissingAttributeInHydraSetError, "Attribute ID #{hydra_attribute1.id} is missed in Set ID #{hydra_set.id}")
+    end
+
+    it 'should delegate to method if it was created in runtime' do
+      HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'one', backend_type: 'string', default_value: 'one')
+      association.delegate(:one).should == 'one'
+    end
+
+    it 'should delegate to method if attribute name was updated in runtime' do
+      hydra_attribute1.name = 'color1'
+      hydra_attribute1.save
+
+      lambda { association.delegate(:color)  }.should raise_error(HydraAttribute::HydraEntityAttributeAssociation::WrongProxyMethodError)
+      lambda { association.delegate(:color1) }.should_not raise_error
+    end
+
+    it 'should delegate to method if attribute entity type was updated in runtime' do
+      hydra_attribute1.entity_type = 'Category'
+      hydra_attribute1.save
+
+      lambda { association.delegate(:color) }.should raise_error(HydraAttribute::HydraEntityAttributeAssociation::WrongProxyMethodError)
+      lambda { HydraAttribute::HydraEntityAttributeAssociation.new(Category.new) }.should_not raise_error
+    end
+
+    it 'should not delegate to method if attribute was deleted in runtime' do
+      hydra_attribute1.destroy
+      lambda { association.delegate(:color) }.should raise_error(HydraAttribute::HydraEntityAttributeAssociation::WrongProxyMethodError)
+    end
+  end
+
+  describe '#hydra_attributes' do
+    let(:entity) { Product.new }
+    let!(:attr1) { HydraAttribute::HydraAttribute.create(entity_type: entity.class.name, name: 'color', backend_type: 'string', default_value: 'red') }
+    let!(:attr2) { HydraAttribute::HydraAttribute.create(entity_type: entity.class.name, name: 'title', backend_type: 'string') }
+    let!(:attr3) { HydraAttribute::HydraAttribute.create(entity_type: entity.class.name, name: 'total', backend_type: 'decimal') }
+
+    let(:hydra_attribute_association) { entity.hydra_attribute_association }
+
+    describe 'entity does not have a hydra set' do
+      describe 'entity is persisted' do
+        before do
+          entity.color = 'green'
+          entity.total = 5
+          entity.save
+        end
+
+        it 'should return all attributes with their values' do
+          hydra_attribute_association.hydra_attributes.should == {'color' => 'green', 'title' => nil, 'total' => 5}
+        end
+      end
+
+      describe 'entity is not persisted' do
+        it 'should return all attributes with their values' do
+          hydra_attribute_association.hydra_attributes.should == {'color' => 'red', 'title' => nil, 'total' => nil}
+        end
+      end
+    end
+
+    describe 'entity has a hydra set' do
+      let(:hydra_set) { HydraAttribute::HydraSet.create(entity_type: entity.class.name, name: 'default') }
+
+      before do
+        HydraAttribute::HydraAttributeSet.create(hydra_attribute_id: attr1.id, hydra_set_id: hydra_set.id)
+        HydraAttribute::HydraAttributeSet.create(hydra_attribute_id: attr3.id, hydra_set_id: hydra_set.id)
+        entity.hydra_set_id = hydra_set.id
+      end
+
+      it 'should return only attributes which are in the hydra set' do
+        hydra_attribute_association.hydra_attributes.should == {'color' => 'red', 'total' => nil}
+      end
+    end
+  end
+
+  describe '#hydra_attributes_before_type_cast' do
+    let(:entity) { Product.new }
+    let!(:attr1) { HydraAttribute::HydraAttribute.create(entity_type: entity.class.name, name: 'purchase_at', backend_type: 'datetime', default_value: '2013-12-04 00:00') }
+    let!(:attr2) { HydraAttribute::HydraAttribute.create(entity_type: entity.class.name, name: 'grand_total', backend_type: 'decimal') }
+
+    let(:hydra_attribute_association) { entity.hydra_attribute_association }
+
+    describe 'entity does not have a hydra set' do
+      describe 'entity is persisted' do
+        before do
+          entity.grand_total = '123456.1234'
+          entity.save
+        end
+
+        it 'should return all attributes with their values' do
+          hydra_attribute_association.hydra_attributes_before_type_cast.should == {'purchase_at' => '2013-12-04 00:00', 'grand_total' => '123456.1234'}
+        end
+      end
+
+      describe 'entity is not persisted' do
+        it 'should return all attributes with their values' do
+          hydra_attribute_association.hydra_attributes_before_type_cast.should == {'purchase_at' => '2013-12-04 00:00', 'grand_total' => nil}
+        end
+      end
+    end
+
+    describe 'entity has a hydra set' do
+      let(:hydra_set) { HydraAttribute::HydraSet.create(entity_type: entity.class.name, name: 'default') }
+
+      before do
+        HydraAttribute::HydraAttributeSet.create(hydra_attribute_id: attr1.id, hydra_set_id: hydra_set.id)
+        entity.hydra_set_id = hydra_set.id
+        entity.save
+      end
+
+      it 'should return only attributes which are in the hydra set' do
+        entity.hydra_attribute_association.hydra_attributes_before_type_cast.should == {'purchase_at' => '2013-12-04 00:00'}
+      end
+    end
+  end
+end

data/spec/hydra_attribute/hydra_entity_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe HydraAttribute::HydraEntity do
+  describe '.hydra_attributes' do
+    it 'should return all hydra attributes for the model' do
+      Product.should have(0).hydra_attributes
+      Category.should have(0).hydra_attributes
+
+      HydraAttribute::HydraAttribute.create(entity_type: 'Product',  name: 'color', backend_type: 'string')
+      HydraAttribute::HydraAttribute.create(entity_type: 'Product',  name: 'title', backend_type: 'string')
+      HydraAttribute::HydraAttribute.create(entity_type: 'Category', name: 'price', backend_type: 'decimal')
+
+      Product.should  have(2).hydra_attributes
+      Category.should have(1).hydra_attributes
+
+      Product.hydra_attributes.map(&:name).should  =~ %w[color title]
+      Category.hydra_attributes.map(&:name).should =~ %w[price]
+    end
+
+    it 'should have a helper method for creating a hydra attribute for this model' do
+      Product.hydra_attributes.create(name: 'height', backend_type: 'string')
+      Product.hydra_attributes.create(name: 'weight', backend_type: 'string')
+      Category.hydra_attributes.create(name: 'total', backend_type: 'decimal')
+
+      Product.hydra_attributes.map(&:name).should  =~ %w[height weight]
+      Category.hydra_attributes.map(&:name).should =~ %w[total]
+    end
+  end
+
+  describe '.hydra_sets' do
+    it 'should return all hydra sets for the model' do
+      Product.should have(0).hydra_sets
+      Category.should have(0).hydra_sets
+
+      HydraAttribute::HydraSet.create(entity_type: 'Product',  name: 'one')
+      HydraAttribute::HydraSet.create(entity_type: 'Product',  name: 'two')
+      HydraAttribute::HydraSet.create(entity_type: 'Category', name: 'three')
+
+      Product.should  have(2).hydra_sets
+      Category.should have(1).hydra_sets
+
+      Product.hydra_sets.map(&:name).should  =~ %w[one two]
+      Category.hydra_sets.map(&:name).should =~ %w[three]
+    end
+
+    it 'should have a helper method for creating a hydra set for this model' do
+      Product.hydra_sets.create(name: 'default1')
+      Product.hydra_sets.create(name: 'default2')
+      Category.hydra_sets.create(name: 'default3')
+
+      Product.hydra_sets.map(&:name).should  =~ %w[default1 default2]
+      Category.hydra_sets.map(&:name).should =~ %w[default3]
+    end
+  end
+
+  describe '#hydra_attributes' do
+    it 'should delegate the method to the hydra_attribute_association object' do
+      product = Product.new
+      product.hydra_attribute_association.should_receive(:hydra_attributes).once.and_return(name: :value)
+      product.hydra_attributes.should == {name: :value}
+    end
+  end
+
+  describe '#hydra_attributes_before_type_cast' do
+    it 'should delegate the method to the hydra_attribute_association object' do
+      product = Product.new
+      product.hydra_attribute_association.should_receive(:hydra_attributes_before_type_cast).once.and_return(name: :value)
+      product.hydra_attributes_before_type_cast.should == {name: :value}
+    end
+  end
+end