hydra_attribute 0.4.2 → 0.5.0.rc1

data/spec/hydra_attribute/hydra_set_spec.rb

@@ -1,19 +1,60 @@
 require 'spec_helper'
 
 describe HydraAttribute::HydraSet do
-  describe '#hydra_attributes=' do
-    let!(:hydra_set) { Product.hydra_sets.create(name: 'Default') }
+  describe '#hydra_attributes' do
+    it 'should return blank array if model has not ID' do
+      HydraAttribute::HydraSet.new.hydra_attributes.should be_blank
+    end
+
+    it 'should return blank array if model has not any hydra_attributes' do
+      hydra_set = HydraAttribute::HydraSet.create(name: 'default', entity_type: 'Product')
+      hydra_set.hydra_attributes.should be_blank
+    end
+
+    it 'should return array of hydra_attributes for the current hydra_set' do
+      hydra_set1       = HydraAttribute::HydraSet.create(entity_type: 'Product', name: 'default1')
+      hydra_set2       = HydraAttribute::HydraSet.create(entity_type: 'Product', name: 'default2')
+      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_attribute3 = HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'attr3', backend_type: 'string')
+
+      HydraAttribute::HydraAttributeSet.create(hydra_set_id: hydra_set1.id, hydra_attribute_id: hydra_attribute1.id)
+      HydraAttribute::HydraAttributeSet.create(hydra_set_id: hydra_set1.id, hydra_attribute_id: hydra_attribute2.id)
+      HydraAttribute::HydraAttributeSet.create(hydra_set_id: hydra_set2.id, hydra_attribute_id: hydra_attribute3.id)
+
+      hydra_set1.should have(2).hydra_attributes
+      hydra_set2.should have(1).hydra_attributes
+
+      hydra_set1.hydra_attributes.should include(hydra_attribute1)
+      hydra_set1.hydra_attributes.should include(hydra_attribute2)
+      hydra_set2.hydra_attributes.should include(hydra_attribute3)
+    end
+  end
+
+  describe 'validations' do
+    it 'should require entity_type' do
+      hydra_set = HydraAttribute::HydraSet.new
+      hydra_set.valid?
+      hydra_set.errors.should include(:entity_type)
+
+      hydra_set.entity_type = 'Product'
+      hydra_set.valid?
+      hydra_set.errors.should_not include(:entity_type)
+    end
+
+    it 'should require name' do
+      hydra_set = HydraAttribute::HydraSet.new
+      hydra_set.valid?
+      hydra_set.errors.should include(:name)
 
-    it 'should clear entity cache if assign hydra attributes collection' do
-      hydra_attribute = Product.hydra_attributes.create(name: 'one', backend_type: 'string')
-      Product.should_receive(:clear_hydra_method_cache!)
-      hydra_set.hydra_attributes = [hydra_attribute]
+      hydra_set.name = 'Default'
+      hydra_set.valid?
+      hydra_set.errors.should_not include(:name)
     end
 
-    it 'should clear entity cache if assign blank collection' do
-      hydra_set.hydra_attributes.create(name: 'one', backend_type: 'string')
-      Product.should_receive(:clear_hydra_method_cache!)
-      hydra_set.hydra_attributes = []
+    it 'should have unique name with entity_type' do
+      HydraAttribute::HydraSet.create(name: 'Default', entity_type: 'Product').should be_persisted
+      HydraAttribute::HydraSet.create(name: 'Default', entity_type: 'Product').should_not be_persisted
     end
   end
 end

data/spec/hydra_attribute/hydra_value_spec.rb

@@ -0,0 +1,286 @@
+require 'spec_helper'
+
+describe HydraAttribute::HydraValue do
+  describe '.arel_tables' do
+    it 'should return hash which holds arel tables for entity table and backend type' do
+      arel_tables = HydraAttribute::HydraValue.arel_tables
+
+      table = arel_tables['products']['string']
+      table.name.should   == 'hydra_string_products'
+      table.engine.should == ActiveRecord::Base
+
+      table = arel_tables['entity_table']['backend_type']
+      table.name.should   == 'hydra_backend_type_entity_table'
+      table.engine.should == ActiveRecord::Base
+    end
+
+    it 'should cache result' do
+      arel_tables = HydraAttribute::HydraValue.arel_tables
+
+      table1 = arel_tables['product_table']['backend_type']
+      table2 = arel_tables['product_table']['backend_type']
+      table1.should be(table2)
+    end
+  end
+
+  describe '.connection' do
+    it 'should return the database connection' do
+      HydraAttribute::HydraValue.connection.should be_a_kind_of(ActiveRecord::ConnectionAdapters::AbstractAdapter)
+    end
+  end
+
+  describe '.column' do
+    it 'should return a column by hydra_attribute_id' do
+      float   = HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'a1', backend_type: 'float',  default_value: 2.5)
+      string  = HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'a2', backend_type: 'string', default_value: 'abc')
+      integer = HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'a3', backend_type: 'integer')
+
+      float_column = HydraAttribute::HydraValue.column(float.id)
+      float_column.should be_a_kind_of(::ActiveRecord::ConnectionAdapters::Column)
+      float_column.name.should     == 'a1'
+      float_column.default.should  == 2.5
+      float_column.sql_type.should == 'float'
+
+      string_column = HydraAttribute::HydraValue.column(string.id)
+      string_column.should be_a_kind_of(::ActiveRecord::ConnectionAdapters::Column)
+      string_column.name.should     == 'a2'
+      string_column.default.should  == 'abc'
+      string_column.sql_type.should == 'string'
+
+      integer_column = HydraAttribute::HydraValue.column(integer.id)
+      integer_column.should be_a_kind_of(::ActiveRecord::ConnectionAdapters::Column)
+      integer_column.name.should     == 'a3'
+      integer_column.default.should be_nil
+      integer_column.sql_type.should == 'integer'
+    end
+  end
+
+  describe '#initialize' do
+    it 'should raise error when :hydra_attribute_id is not passed to initialize' do
+      lambda do
+        HydraAttribute::HydraValue.new(Product.new)
+      end.should raise_error(HydraAttribute::HydraValue::HydraAttributeIdIsMissedError, 'Key :hydra_attribute_id is missed')
+    end
+
+    it 'should not raise error when :hydra_attribute_id is passed' do
+      attr = HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'price', backend_type: 'float')
+
+      lambda do
+        HydraAttribute::HydraValue.new(Product.new, hydra_attribute_id: attr.id)
+      end.should_not raise_error
+    end
+  end
+
+  describe '#column' do
+    let(:hydra_value)        { HydraAttribute::HydraValue.new(Product.new, hydra_attribute_id: hydra_attribute_id) }
+    let(:hydra_attribute_id) { HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'code', backend_type: backend_type).id }
+
+    describe 'for string hydra_attribute' do
+      let(:backend_type) { 'string' }
+
+      it 'should return string virtual column' do
+        hydra_value.column.should be_a_kind_of(::ActiveRecord::ConnectionAdapters::Column)
+        hydra_value.column.sql_type.should == 'string'
+      end
+    end
+
+    describe 'for integer hydra attribute' do
+      let(:backend_type) { 'integer' }
+
+      it 'should return integer virtual column' do
+        hydra_value.column.should be_a_kind_of(::ActiveRecord::ConnectionAdapters::Column)
+        hydra_value.column.sql_type.should == 'integer'
+      end
+    end
+  end
+
+  describe '#id' do
+    let(:hydra_attribute) { HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'price', backend_type: 'float') }
+
+    it 'should return model ID' do
+      hydra_value = HydraAttribute::HydraValue.new(Product.new, hydra_attribute_id: hydra_attribute.id, id: 2)
+      hydra_value.id.should be(2)
+
+      hydra_value = HydraAttribute::HydraValue.new(Product.new, hydra_attribute_id: hydra_attribute.id)
+      hydra_value.id.should be_nil
+    end
+  end
+
+  describe '#value' do
+    it 'should return default value' do
+      hydra_attribute = HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'code', backend_type: 'string', default_value: 'abc')
+
+      hydra_value = HydraAttribute::HydraValue.new(Product.new, hydra_attribute_id: hydra_attribute.id)
+      hydra_value.value.should == 'abc'
+
+      hydra_value = HydraAttribute::HydraValue.new(Product.new, hydra_attribute_id: hydra_attribute.id, value: 'qwerty')
+      hydra_value.value.should == 'qwerty'
+    end
+
+    it 'should return type casted value' do
+      hydra_attribute = HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'code', backend_type: 'integer')
+
+      hydra_value = HydraAttribute::HydraValue.new(Product.new, hydra_attribute_id: hydra_attribute.id, value: '12a')
+      hydra_value.value.should == 12
+    end
+  end
+
+  describe '#value=' do
+    it 'should change current value' do
+      hydra_attribute = HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'code', backend_type: 'string')
+
+      hydra_value = HydraAttribute::HydraValue.new(Product.new, hydra_attribute_id: hydra_attribute.id, value: 'abc')
+      hydra_value.value = 'www'
+      hydra_value.value.should == 'www'
+    end
+
+    it 'should type cast value before assign it' do
+      hydra_attribute = HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'price', backend_type: 'float')
+
+      hydra_value = HydraAttribute::HydraValue.new(Product.new, hydra_attribute_id: hydra_attribute.id)
+
+      hydra_value.value = '2.57a'
+      hydra_value.value.should == 2.57
+
+      hydra_value.value = 'a'
+      hydra_value.value.should == 0.0
+    end
+  end
+
+  describe '#value?' do
+    let(:hydra_attribute) { HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'price', backend_type: backend_type) }
+    let(:hydra_value)     { HydraAttribute::HydraValue.new(Product.new, hydra_attribute_id: hydra_attribute.id) }
+
+    describe 'integer attribute' do
+      let(:backend_type) { 'integer' }
+
+      it 'should be true for 1' do
+        hydra_value.value = 1
+        hydra_value.value?.should be_true
+      end
+
+      it 'should be false for 0' do
+        hydra_value.value = 0
+        hydra_value.value?.should be_false
+      end
+
+      it 'should be false for nil' do
+        hydra_value.value = nil
+        hydra_value.value?.should be_false
+      end
+    end
+
+    describe 'string attribute' do
+      let(:backend_type) { 'string' }
+
+      it 'should be true for "abc"' do
+        hydra_value.value = 'abc'
+        hydra_value.value?.should be_true
+      end
+
+      it 'should be false for ""' do
+        hydra_value.value = ''
+        hydra_value.value?.should be_false
+      end
+
+      it 'should be false for nil' do
+        hydra_value.value = nil
+        hydra_value.value?.should be_false
+      end
+    end
+  end
+
+  describe '#value_before_type_cast' do
+    let(:hydra_attribute) { HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'price', backend_type: 'float') }
+    let(:hydra_value)     { HydraAttribute::HydraValue.new(Product.new, hydra_attribute_id: hydra_attribute.id) }
+
+    it 'should return not type casted value' do
+      hydra_value.value = '2.0'
+      hydra_value.value_before_type_cast.should == '2.0'
+
+      hydra_value.value = 'aaa'
+      hydra_value.value_before_type_cast.should == 'aaa'
+    end
+  end
+
+  describe '#hydra_attribute' do
+    it 'should return hydra attribute model' do
+      hydra_attribute = HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'price', backend_type: 'float')
+
+      hydra_value = HydraAttribute::HydraValue.new(Product.new, hydra_attribute_id: hydra_attribute.id)
+      hydra_value.hydra_attribute.should be(hydra_attribute)
+    end
+  end
+
+  describe '#persisted?' do
+    let(:hydra_attribute) { HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'price', backend_type: 'float') }
+
+    it 'should return true if model has ID' do
+      hydra_value = HydraAttribute::HydraValue.new(Product.new, hydra_attribute_id: hydra_attribute.id, id: 2)
+      hydra_value.should be_persisted
+    end
+
+    it 'should return false unless model has ID' do
+      hydra_value = HydraAttribute::HydraValue.new(Product.new, hydra_attribute_id: hydra_attribute.id)
+      hydra_value.should_not be_persisted
+    end
+  end
+
+  describe '#save' do
+    let(:product)         { Product.create! }
+    let(:hydra_attribute) { HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'price', backend_type: 'float', default_value: 0.1) }
+
+    it 'should raise an error if entity model is not persisted' do
+      hydra_value = HydraAttribute::HydraValue.new(Product.new, hydra_attribute_id: hydra_attribute.id)
+      lambda do
+        hydra_value.save
+      end.should raise_error(HydraAttribute::HydraValue::EntityModelIsNotPersistedError, 'HydraValue model cannot be saved is entity model is not persisted')
+    end
+
+    describe 'create' do
+      it 'should create model with default value' do
+        hydra_value = HydraAttribute::HydraValue.new(product, hydra_attribute_id: hydra_attribute.id)
+        hydra_value.save
+
+        value = product.connection.select_value("SELECT value FROM hydra_float_products WHERE entity_id=#{product.id} AND hydra_attribute_id=#{hydra_attribute.id}")
+        value.to_f.should == 0.1
+      end
+
+      it 'should create model with changed value' do
+        hydra_value = HydraAttribute::HydraValue.new(product, hydra_attribute_id: hydra_attribute.id)
+        hydra_value.value = 2.5
+        hydra_value.save
+
+        value = product.connection.select_value("SELECT value FROM hydra_float_products WHERE id=#{hydra_value.id}")
+        value.to_f.should == 2.5
+      end
+    end
+
+    describe 'update' do
+      it 'should update hydra value in database' do
+        hydra_value = HydraAttribute::HydraValue.new(product, hydra_attribute_id: hydra_attribute.id)
+        hydra_value.value = 2.5
+        hydra_value.save
+
+        hydra_value.value = 5.5
+        hydra_value.save
+
+        value = product.connection.select_value("SELECT value FROM hydra_float_products WHERE id=#{hydra_value.id}")
+        value.to_f.should == 5.5
+      end
+    end
+  end
+
+  describe 'value methods' do
+    let(:hydra_attribute) { HydraAttribute::HydraAttribute.create(entity_type: 'Product', name: 'code', backend_type: 'string') }
+
+    it 'should respond to dirty methods' do
+      hydra_value = HydraAttribute::HydraValue.new(Product.new, hydra_attribute_id: hydra_attribute.id)
+      hydra_value.should respond_to(:value_changed?)
+      hydra_value.should respond_to(:value_change)
+      hydra_value.should respond_to(:value_will_change!)
+      hydra_value.should respond_to(:value_was)
+      hydra_value.should respond_to(:reset_value!)
+    end
+  end
+end

data/spec/hydra_attribute/identity_map_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe HydraAttribute::IdentityMap do
+  it 'acts like Hash' do
+    HydraAttribute::IdentityMap.should < Hash
+  end
+
+  describe '#cache' do
+    it 'should store value into cache' do
+      identity_map = HydraAttribute::IdentityMap.new
+      identity_map.cache(:abc, 1).should be(1)
+      identity_map[:abc].should be(1)
+    end
+
+    it 'should return value from cache if it exists' do
+      identity_map = HydraAttribute::IdentityMap.new
+      identity_map[:abc] = 1
+
+      identity_map.cache(:abc, 2).should be(1)
+      identity_map[:abc].should be(1)
+    end
+
+    it 'should accept block for storing value into cache' do
+      identity_map = HydraAttribute::IdentityMap.new
+
+      value = identity_map.cache(:abc) { 3 }
+      value.should be(3)
+      identity_map[:abc].should be(3)
+    end
+
+    it 'should return value from cache if it exists and block is passed' do
+      identity_map = HydraAttribute::IdentityMap.new
+      identity_map[:abc] = 1
+
+      value = identity_map.cache(:abc) { 3 }
+      value.should be(1)
+      identity_map[:abc].should be(1)
+    end
+
+    its 'block should have higher priority then value' do
+      identity_map = HydraAttribute::IdentityMap.new
+      value = identity_map.cache(:abc, 1) { 2 }
+      value.should be(2)
+      identity_map[:abc].should be(2)
+    end
+  end
+end

data/spec/hydra_attribute/migrator_spec.rb

@@ -0,0 +1,411 @@
+require 'spec_helper'
+
+describe HydraAttribute::Migrator do
+  let(:connection)     { ActiveRecord::Base.connection }
+  let(:migrator)       { HydraAttribute::Migrator.new(connection) }
+  let(:backend_tables) { ->(entity){ HydraAttribute::SUPPORTED_BACKEND_TYPES.map { |type| "hydra_#{type}_#{entity}" }} }
+
+  describe '#create' do
+    after { migrator.drop(:wheels) }
+
+    before do
+      migrator.create :wheels do |t|
+        t.string :name
+        t.timestamps
+      end
+    end
+
+    describe 'entity' do
+      let(:columns) { connection.columns(:wheels) }
+
+      it 'should have the necessary columns' do
+        columns.map(&:name).should =~ %w[id hydra_set_id name created_at updated_at]
+      end
+
+      it 'should have a correct column types' do
+        column = columns.find { |c| c.name == 'hydra_set_id' }
+        column.null.should be_true
+        case ENV['DB']
+        when 'postgresql' then column.sql_type.should == 'integer'
+        when 'mysql'      then column.sql_type.should == 'int(11)'
+        when 'sqlite'     then column.sql_type.should == 'integer'
+        else raise 'Unknown database'
+        end
+      end
+
+      it 'should have a correct indexes' do
+        index = connection.indexes(:wheels).find { |i| i.name == 'wheels_hydra_set_id_idx' }
+        index.unique.should be_false
+        index.columns.should == %w[hydra_set_id]
+      end
+    end
+
+    describe 'hydra_attributes' do
+      let(:columns) { connection.columns(:hydra_attributes) }
+
+      it 'should have the necessary columns' do
+        columns.map(&:name).should =~ %w[id entity_type name backend_type default_value white_list created_at updated_at]
+      end
+
+      it 'should have a correct column types' do
+        column = columns.find { |c| c.name == 'entity_type' }
+        column.sql_type.should == (ENV['DB'] == 'postgresql' ? 'character varying(32)' : 'varchar(32)')
+        column.null.should be_false
+
+        column = columns.find { |c| c.name == 'name' }
+        column.sql_type.should == (ENV['DB'] == 'postgresql' ? 'character varying(32)' : 'varchar(32)')
+        column.null.should be_false
+
+        column = columns.find { |c| c.name == 'backend_type' }
+        column.sql_type.should == (ENV['DB'] == 'postgresql' ? 'character varying(16)' : 'varchar(16)')
+        column.null.should be_false
+
+        column = columns.find { |c| c.name == 'default_value' }
+        column.sql_type.should == (ENV['DB'] == 'postgresql' ? 'character varying(255)' : 'varchar(255)')
+        column.null.should be_true
+
+        column = columns.find { |c| c.name == 'white_list' }
+        column.null.should be_false
+        column.default.should be_false
+        case ENV['DB']
+        when 'postgresql' then column.sql_type.should == 'boolean'
+        when 'mysql'      then column.sql_type.should == 'tinyint(1)'
+        when 'sqlite'     then column.sql_type.should == 'boolean'
+        else raise 'Unknown database'
+        end
+
+        column = columns.find { |c| c.name == 'created_at' }
+        column.null.should be_false
+        case ENV['DB']
+        when 'postgresql' then column.sql_type.should == 'timestamp without time zone'
+        when 'mysql'      then column.sql_type.should == 'datetime'
+        when 'sqlite'     then column.sql_type.should == 'datetime'
+        else raise 'Unknown database'
+        end
+
+        column = columns.find { |c| c.name == 'updated_at' }
+        column.null.should be_false
+        case ENV['DB']
+        when 'postgresql' then column.sql_type.should == 'timestamp without time zone'
+        when 'mysql'      then column.sql_type.should == 'datetime'
+        when 'sqlite'     then column.sql_type.should == 'datetime'
+        else raise 'Unknown database'
+        end
+      end
+
+      it 'should have a correct indexes' do
+        connection.indexes(:hydra_attributes).should have(1).indexes
+        connection.indexes(:hydra_attributes)[0].name.should   == 'hydra_attributes_idx'
+        connection.indexes(:hydra_attributes)[0].unique.should be_true
+        connection.indexes(:hydra_attributes)[0].columns.should == %w[entity_type name]
+      end
+    end
+
+    describe 'hydra_sets' do
+      let(:columns) { connection.columns(:hydra_sets) }
+
+      it 'should have the necessary columns' do
+        columns.map(&:name).should =~ %w[id entity_type name created_at updated_at]
+      end
+
+      it 'should have a correct column types' do
+        column = columns.find { |c| c.name == 'entity_type' }
+        column.sql_type.should == (ENV['DB'] == 'postgresql' ? 'character varying(32)' : 'varchar(32)')
+        column.null.should be_false
+
+        column = columns.find { |c| c.name == 'name' }
+        column.sql_type.should == (ENV['DB'] == 'postgresql' ? 'character varying(32)' : 'varchar(32)')
+        column.null.should be_false
+
+        column = columns.find { |c| c.name == 'created_at' }
+        column.sql_type.should == (ENV['DB'] == 'postgresql' ? 'timestamp without time zone' : 'datetime')
+        column.null.should be_false
+
+        column = columns.find { |c| c.name == 'updated_at' }
+        column.sql_type.should == (ENV['DB'] == 'postgresql' ? 'timestamp without time zone' : 'datetime')
+        column.null.should be_false
+      end
+
+      it 'should have a correct indexes' do
+        connection.indexes(:hydra_sets).should have(1).indexes
+        connection.indexes(:hydra_sets)[0].name.should   == 'hydra_sets_idx'
+        connection.indexes(:hydra_sets)[0].unique.should be_true
+        connection.indexes(:hydra_sets)[0].columns.should == %w[entity_type name]
+      end
+    end
+
+    describe 'hydra_attribute_sets' do
+      let(:columns) { connection.columns(:hydra_attribute_sets) }
+
+      it 'should have the necessary columns' do
+        columns.map(&:name).should =~ %w[id hydra_attribute_id hydra_set_id created_at updated_at]
+      end
+
+      it 'should have a correct column types' do
+        column = columns.find { |c| c.name == 'hydra_attribute_id' }
+        column.null.should be_false
+        case ENV['DB']
+        when 'postgresql' then column.sql_type.should == 'integer'
+        when 'mysql'      then column.sql_type.should == 'int(11)'
+        when 'sqlite'     then column.sql_type.should == 'integer'
+        else raise 'Unknown database'
+        end
+
+        column = columns.find { |c| c.name == 'hydra_set_id' }
+        column.null.should be_false
+        case ENV['DB']
+        when 'postgresql' then column.sql_type.should == 'integer'
+        when 'mysql'      then column.sql_type.should == 'int(11)'
+        when 'sqlite'     then column.sql_type.should == 'integer'
+        else raise 'Unknown database'
+        end
+
+        column = columns.find { |c| c.name == 'created_at' }
+        column.null.should be_false
+        case ENV['DB']
+        when 'postgresql' then column.sql_type.should == 'timestamp without time zone'
+        when 'mysql'      then column.sql_type.should == 'datetime'
+        when 'sqlite'     then column.sql_type.should == 'datetime'
+        else raise 'Unknown database'
+        end
+
+        column = columns.find { |c| c.name == 'updated_at' }
+        column.null.should be_false
+        case ENV['DB']
+        when 'postgresql' then column.sql_type.should == 'timestamp without time zone'
+        when 'mysql'      then column.sql_type.should == 'datetime'
+        when 'sqlite'     then column.sql_type.should == 'datetime'
+        else raise 'Unknown database'
+        end
+      end
+
+      it 'should have a correct indexes' do
+        connection.indexes(:hydra_attribute_sets).should have(1).indexes
+        connection.indexes(:hydra_attribute_sets)[0].name.should    == 'hydra_attribute_sets_idx'
+        connection.indexes(:hydra_attribute_sets)[0].unique.should  be_true
+        connection.indexes(:hydra_attribute_sets)[0].columns.should == %w[hydra_attribute_id hydra_set_id]
+      end
+    end
+
+    describe 'values' do
+      it 'should have the following value tables' do
+        connection.table_exists?('hydra_string_wheels').should   be_true
+        connection.table_exists?('hydra_text_wheels').should     be_true
+        connection.table_exists?('hydra_float_wheels').should    be_true
+        connection.table_exists?('hydra_decimal_wheels').should  be_true
+        connection.table_exists?('hydra_boolean_wheels').should  be_true
+        connection.table_exists?('hydra_datetime_wheels').should be_true
+      end
+
+      it 'should have the correct column types' do
+        %w[hydra_string_wheels hydra_text_wheels hydra_float_wheels hydra_boolean_wheels hydra_datetime_wheels].each do |table|
+          column = connection.columns(table).find { |c| c.name == 'entity_id' }
+          column.null.should be_false
+          case ENV['DB']
+          when 'postgresql' then column.sql_type.should == 'integer'
+          when 'mysql'      then column.sql_type.should == 'int(11)'
+          when 'sqlite'     then column.sql_type.should == 'integer'
+          else raise 'Unknown database'
+          end
+
+          column = connection.columns(table).find { |c| c.name == 'hydra_attribute_id' }
+          column.null.should be_false
+          case ENV['DB']
+          when 'postgresql' then column.sql_type.should == 'integer'
+          when 'mysql'      then column.sql_type.should == 'int(11)'
+          when 'sqlite'     then column.sql_type.should == 'integer'
+          else raise 'Unknown database'
+          end
+
+          column = connection.columns(table).find { |c| c.name == 'created_at' }
+          column.null.should be_false
+          case ENV['DB']
+          when 'postgresql' then column.sql_type.should == 'timestamp without time zone'
+          when 'mysql'      then column.sql_type.should == 'datetime'
+          when 'sqlite'     then column.sql_type.should == 'datetime'
+          else raise 'Unknown database'
+          end
+
+          column = connection.columns(table).find { |c| c.name == 'updated_at' }
+          column.null.should be_false
+          case ENV['DB']
+          when 'postgresql' then column.sql_type.should == 'timestamp without time zone'
+          when 'mysql'      then column.sql_type.should == 'datetime'
+          when 'sqlite'     then column.sql_type.should == 'datetime'
+          else raise 'Unknown database'
+          end
+        end
+
+        column = connection.columns('hydra_string_wheels').find { |c| c.name == 'value' }
+        column.null.should be_true
+        case ENV['DB']
+        when 'postgresql' then column.sql_type.should == 'character varying(255)'
+        when 'mysql'      then column.sql_type.should == 'varchar(255)'
+        when 'sqlite'     then column.sql_type.should == 'varchar(255)'
+        else raise 'Unknown database'
+        end
+
+        column = connection.columns('hydra_text_wheels').find { |c| c.name == 'value' }
+        column.null.should be_true
+        column.sql_type.should == 'text'
+
+        column = connection.columns('hydra_integer_wheels').find { |c| c.name == 'value' }
+        column.null.should be_true
+        case ENV['DB']
+        when 'postgresql' then column.sql_type.should == 'integer'
+        when 'mysql'      then column.sql_type.should == 'int(11)'
+        when 'sqlite'     then column.sql_type.should == 'integer'
+        else raise 'Unknown database'
+        end
+
+        column = connection.columns('hydra_float_wheels').find { |c| c.name == 'value' }
+        column.null.should be_true
+        case ENV['DB']
+        when 'postgresql' then column.sql_type.should == 'double precision'
+        when 'mysql'      then column.sql_type.should == 'float'
+        when 'sqlite'     then column.sql_type.should == 'float'
+        else raise 'Unknown database'
+        end
+
+        column = connection.columns('hydra_decimal_wheels').find { |c| c.name == 'value' }
+        column.null.should      be_true
+        column.precision.should be(10)
+        column.scale.should     be(4)
+        case ENV['DB']
+        when 'postgresql' then column.sql_type.should == 'numeric(10,4)'
+        when 'mysql'      then column.sql_type.should == 'decimal(10,4)'
+        when 'sqlite'     then column.sql_type.should == 'decimal(10,4)'
+        else raise 'Unknown database'
+        end
+
+        column = connection.columns('hydra_boolean_wheels').find { |c| c.name == 'value' }
+        column.null.should be_true
+        case ENV['DB']
+        when 'postgresql' then column.sql_type.should == 'boolean'
+        when 'mysql'      then column.sql_type.should == 'tinyint(1)'
+        when 'sqlite'     then column.sql_type.should == 'boolean'
+        else raise 'Unknown database'
+        end
+
+        column = connection.columns('hydra_datetime_wheels').find { |c| c.name == 'value' }
+        column.null.should be_true
+        case ENV['DB']
+        when 'postgresql' then column.sql_type.should == 'timestamp without time zone'
+        when 'mysql'      then column.sql_type.should == 'datetime'
+        when 'sqlite'     then column.sql_type.should == 'datetime'
+        else raise 'Unknown database'
+        end
+      end
+
+      it 'should have a correct indexes' do
+        connection.indexes(:hydra_string_wheels).should have(1).indexes
+        connection.indexes(:hydra_string_wheels)[0].name.should    == 'hydra_string_wheels_idx'
+        connection.indexes(:hydra_string_wheels)[0].unique.should  be_true
+        connection.indexes(:hydra_string_wheels)[0].columns.should == %w[entity_id hydra_attribute_id]
+
+        connection.indexes(:hydra_text_wheels).should have(1).indexes
+        connection.indexes(:hydra_text_wheels)[0].name.should    == 'hydra_text_wheels_idx'
+        connection.indexes(:hydra_text_wheels)[0].unique.should  be_true
+        connection.indexes(:hydra_text_wheels)[0].columns.should == %w[entity_id hydra_attribute_id]
+
+        connection.indexes(:hydra_integer_wheels).should have(1).indexes
+        connection.indexes(:hydra_integer_wheels)[0].name.should    == 'hydra_integer_wheels_idx'
+        connection.indexes(:hydra_integer_wheels)[0].unique.should  be_true
+        connection.indexes(:hydra_integer_wheels)[0].columns.should == %w[entity_id hydra_attribute_id]
+
+        connection.indexes(:hydra_float_wheels).should have(1).indexes
+        connection.indexes(:hydra_float_wheels)[0].name.should    == 'hydra_float_wheels_idx'
+        connection.indexes(:hydra_float_wheels)[0].unique.should  be_true
+        connection.indexes(:hydra_float_wheels)[0].columns.should == %w[entity_id hydra_attribute_id]
+
+        connection.indexes(:hydra_decimal_wheels).should have(1).indexes
+        connection.indexes(:hydra_decimal_wheels)[0].name.should    == 'hydra_decimal_wheels_idx'
+        connection.indexes(:hydra_decimal_wheels)[0].unique.should  be_true
+        connection.indexes(:hydra_decimal_wheels)[0].columns.should == %w[entity_id hydra_attribute_id]
+
+        connection.indexes(:hydra_boolean_wheels).should have(1).indexes
+        connection.indexes(:hydra_boolean_wheels)[0].name.should    == 'hydra_boolean_wheels_idx'
+        connection.indexes(:hydra_boolean_wheels)[0].unique.should  be_true
+        connection.indexes(:hydra_boolean_wheels)[0].columns.should == %w[entity_id hydra_attribute_id]
+
+        connection.indexes(:hydra_datetime_wheels).should have(1).indexes
+        connection.indexes(:hydra_datetime_wheels)[0].name.should    == 'hydra_datetime_wheels_idx'
+        connection.indexes(:hydra_datetime_wheels)[0].unique.should  be_true
+        connection.indexes(:hydra_datetime_wheels)[0].columns.should == %w[entity_id hydra_attribute_id]
+      end
+    end
+  end
+
+  describe '#drop' do
+    it 'should drop entity and hydra tables' do
+      migrator.create :wheels
+      connection.table_exists?(:wheels).should                be_true
+      connection.table_exists?(:hydra_string_wheels).should   be_true
+      connection.table_exists?(:hydra_text_wheels).should     be_true
+      connection.table_exists?(:hydra_integer_wheels).should  be_true
+      connection.table_exists?(:hydra_float_wheels).should    be_true
+      connection.table_exists?(:hydra_boolean_wheels).should  be_true
+      connection.table_exists?(:hydra_datetime_wheels).should be_true
+
+      migrator.drop :wheels
+      connection.table_exists?(:wheels).should                be_false
+      connection.table_exists?(:hydra_string_wheels).should   be_false
+      connection.table_exists?(:hydra_text_wheels).should     be_false
+      connection.table_exists?(:hydra_integer_wheels).should  be_false
+      connection.table_exists?(:hydra_float_wheels).should    be_false
+      connection.table_exists?(:hydra_boolean_wheels).should  be_false
+      connection.table_exists?(:hydra_datetime_wheels).should be_false
+    end
+  end
+
+  describe '#migrate' do
+    before { connection.create_table :wheels }
+    after  { connection.drop_table :wheels   }
+
+    it 'should create hydra tables for entity' do
+      connection.table_exists?(:wheels).should                be_true
+      connection.table_exists?(:hydra_string_wheels).should   be_false
+      connection.table_exists?(:hydra_text_wheels).should     be_false
+      connection.table_exists?(:hydra_integer_wheels).should  be_false
+      connection.table_exists?(:hydra_float_wheels).should    be_false
+      connection.table_exists?(:hydra_boolean_wheels).should  be_false
+      connection.table_exists?(:hydra_datetime_wheels).should be_false
+
+      migrator.migrate :wheels
+      connection.table_exists?(:wheels).should                be_true
+      connection.table_exists?(:hydra_string_wheels).should   be_true
+      connection.table_exists?(:hydra_text_wheels).should     be_true
+      connection.table_exists?(:hydra_integer_wheels).should  be_true
+      connection.table_exists?(:hydra_float_wheels).should    be_true
+      connection.table_exists?(:hydra_boolean_wheels).should  be_true
+      connection.table_exists?(:hydra_datetime_wheels).should be_true
+
+      migrator.rollback :wheels
+    end
+  end
+
+  describe '#rollback' do
+    before { connection.create_table :wheels }
+    after  { connection.drop_table :wheels   }
+
+    it 'should drop hydra tables for entity' do
+      migrator.migrate :wheels
+      connection.table_exists?(:wheels).should                be_true
+      connection.table_exists?(:hydra_string_wheels).should   be_true
+      connection.table_exists?(:hydra_text_wheels).should     be_true
+      connection.table_exists?(:hydra_integer_wheels).should  be_true
+      connection.table_exists?(:hydra_float_wheels).should    be_true
+      connection.table_exists?(:hydra_boolean_wheels).should  be_true
+      connection.table_exists?(:hydra_datetime_wheels).should be_true
+
+      migrator.rollback :wheels
+      connection.table_exists?(:wheels).should                be_true
+      connection.table_exists?(:hydra_string_wheels).should   be_false
+      connection.table_exists?(:hydra_text_wheels).should     be_false
+      connection.table_exists?(:hydra_integer_wheels).should  be_false
+      connection.table_exists?(:hydra_float_wheels).should    be_false
+      connection.table_exists?(:hydra_boolean_wheels).should  be_false
+      connection.table_exists?(:hydra_datetime_wheels).should be_false
+    end
+  end
+end