hydra_attribute 0.2.0 → 0.3.0.beta1

data/spec/hydra_attribute/active_record/relation/query_methods_spec.rb

@@ -1,334 +0,0 @@
-require 'spec_helper'
-
-describe HydraAttribute::ActiveRecord::Relation::QueryMethods do
-  let(:relation_class) do
-    mock(
-      :hydra_attributes      => {'code' => :string},
-      :hydra_attribute_names => ['code'],
-      :hydra_attribute_types => [:string]
-    )
-  end
-
-  let(:relation) { mock(klass: relation_class, where: nil) }
-
-  before do
-    relation.singleton_class.send :include, ::ActiveRecord::QueryMethods
-    relation.singleton_class.send :include, HydraAttribute::ActiveRecord::Relation::QueryMethods
-  end
-
-  describe '#where' do
-    let(:relation) do
-      mock_relation = mock(klass: relation_class)
-      mock_relation.instance_variable_set(:@where_values, [])
-      mock_relation.instance_variable_set(:@joins_values, [])
-      mock_relation.stub(:build_hydra_joins_values)  { |name, value| ["join-#{name}-#{value}"]  }
-      mock_relation.stub(:build_hydra_where_options) { |name, value| ["where-#{name}-#{value}"] }
-      mock_relation.stub(:build_where)               { |value, *rest| ["#{value} #{rest}"] }
-      mock_relation
-    end
-
-    before do
-      module HydraAttribute
-        class StringAttribute
-          def self.table_name
-            'hydra_string_attributes'
-          end
-        end
-      end
-    end
-
-    after do
-      HydraAttribute.send :remove_const, :StringAttribute
-    end
-
-    describe 'first param is Hash' do
-      let(:params) { {'title' => 1} }
-
-      describe 'hash has not hydra attribute' do
-        it 'should call rails native "where" method' do
-          object = relation.where(params)
-          object.where_values.should        == ['{"title"=>1} [[]]']
-          object.joins_values.should        == []
-          object.hydra_joins_aliases.should == []
-        end
-      end
-
-      describe 'hash has hydra attribute' do
-        let(:params) { {'title' => 1, 'code' => 2, 'name' => 3} }
-
-        it 'should call both native and overwritten "where" method' do
-          copy_relation = relation.where(params)
-          copy_relation.where_values.should        == ['{"title"=>1} [[]]', 'where-code-2 []', '{"name"=>3} [[]]']
-          copy_relation.joins_values.should        == ['join-code-2']
-          copy_relation.hydra_joins_aliases.should == ['hydra_string_attributes_inner_code']
-        end
-      end
-    end
-
-    describe 'first param is not Hash' do
-      let(:params) { 'name = 1' }
-
-      it 'should call rails native "where" method' do
-        copy_relation = relation.where(params)
-        copy_relation.where_values.should        == ['name = 1 [[]]']
-        copy_relation.joins_values.should        == []
-        copy_relation.hydra_joins_aliases.should == []
-      end
-    end
-  end
-
-  describe '#build_arel' do
-    let(:arel) { mock.as_null_object }
-
-    let(:relation) do
-      mock_relation = mock(klass: relation_class, where: nil, build_select: nil)
-      mock_relation.stub_chain(:table, :from).and_return(arel)
-      mock_relation.instance_variable_set(:@joins_values, [])
-      mock_relation.instance_variable_set(:@order_values, [])
-      mock_relation.instance_variable_set(:@where_values, [])
-      mock_relation.instance_variable_set(:@having_values, [])
-      mock_relation.instance_variable_set(:@group_values, [])
-      mock_relation.instance_variable_set(:@select_values, [])
-      mock_relation
-    end
-
-    it 'should update @order_values before generate the arel object' do
-      relation.stub(build_hydra_values_for_arel: %w(build_order))
-      relation.build_arel.should == arel
-      relation.instance_variable_get(:@order_values).should == %w(build_order)
-    end
-  end
-
-  describe '#build_hydra_values_for_arel' do
-    let(:connection) do
-      conn = mock
-      conn.stub(:quote_column_name) { |column| column.to_s        }
-      conn.stub(:quote)             { |value| %Q("#{value.to_s}") }
-      conn.stub(:quote_table_name)  { |table| table.to_s          }
-      conn
-    end
-
-    let(:relation_class) do
-      mock(connection: connection, quoted_table_name: 'product', hydra_attribute_names: %w(code title price))
-    end
-
-    let(:relation) do
-      mock_relation = mock(klass: relation_class, connection: connection)
-      mock_relation.stub(where: mock_relation)
-      mock_relation.stub(:hydra_ref_alias)          { |name, value| "#{name}_#{value}"        }
-      mock_relation.stub(:build_hydra_joins_values) { |name, value| ["#{name}_#{value}_join"] }
-      mock_relation.instance_variable_set(:@joins_values, [])
-      mock_relation.instance_variable_set(:@hydra_joins_aliases, %w(code_inner title_))
-      mock_relation
-    end
-
-    describe 'collection has not hydra attributes' do
-      it 'should return the same collection' do
-        relation.send(:build_hydra_values_for_arel, %w(name zone)).should == %w(product.name product.zone)
-        relation.joins_values.should == []
-      end
-    end
-
-    describe 'collection has hydra attributes' do
-      it 'should change hydra attributes and join hydra tables' do
-        relation.send(:build_hydra_values_for_arel, %w(name code title price)).should == %w(product.name code_inner.value title_.value price_.value)
-        relation.joins_values.should == %w(price__join)
-      end
-    end
-  end
-
-  describe '#build_hydra_joins_values' do
-    let(:connection) do
-      conn = mock
-      conn.stub(:quote_column_name) { |column| column.to_s        }
-      conn.stub(:quote)             { |value| %Q("#{value.to_s}") }
-      conn.stub(:quote_table_name)  { |table| table.to_s          }
-      conn
-    end
-
-    let(:relation_class) do
-      mock(
-        :connection         => connection,
-        :base_class         => mock(name: 'BaseClass'),
-        :quoted_primary_key => 'id',
-        :quoted_table_name  => 'hydra_string_attributes'
-      )
-    end
-
-    let(:relation) do
-      mock_relation = mock(klass: relation_class)
-      mock_relation.stub(where: mock_relation)
-      mock_relation.stub(:hydra_ref_alias) { |name, value| "#{name}_#{value}" }
-      mock_relation.stub(:hydra_ref_table) { |name| "table_#{name}"           }
-      mock_relation
-    end
-
-    describe 'value is nil' do
-      let(:value) { nil }
-      let(:sql)   { 'LEFT JOIN table_name AS name_ ON hydra_string_attributes.id = name_.entity_id AND name_.entity_type = "BaseClass" AND name_.name = "name"' }
-
-      it 'should return array with one SQL query element' do
-        relation.send(:build_hydra_joins_values, :name, value).should == [sql]
-      end
-    end
-
-    describe 'value is not nil' do
-      let(:value) { 'value' }
-      let(:sql)   { 'INNER JOIN table_name AS name_value ON hydra_string_attributes.id = name_value.entity_id AND name_value.entity_type = "BaseClass" AND name_value.name = "name"' }
-
-      it 'should return array with one SQL query element' do
-        relation.send(:build_hydra_joins_values, :name, value).should == [sql]
-      end
-    end
-  end
-
-  describe '#build_hydra_where_options' do
-    before do
-      module HydraAttribute
-        class StringAttribute
-          def self.table_name
-            'hydra_string_attributes'
-          end
-        end
-      end
-    end
-
-    after { HydraAttribute.send :remove_const, :StringAttribute }
-
-    it 'should create where options with table namespace' do
-      relation.send(:build_hydra_where_options, 'code', 'abc').should == {'hydra_string_attributes_inner_code' => { value: 'abc' }}
-    end
-  end
-
-  describe '#hydra_ref_class' do
-    before do
-      module HydraAttribute
-        class StringAttribute
-          def self.table_name
-            'hydra_string_attributes'
-          end
-        end
-      end
-    end
-
-    after { HydraAttribute.send :remove_const, :StringAttribute }
-
-    it 'should return class by attribute name' do
-      relation.send(:hydra_ref_class, 'code').should == HydraAttribute::StringAttribute
-    end
-  end
-
-  describe '#hydra_ref_table' do
-    before do
-      module HydraAttribute
-        class StringAttribute
-          def self.table_name
-            'hydra_string_attributes'
-          end
-        end
-      end
-    end
-
-    after { HydraAttribute.send :remove_const, :StringAttribute }
-
-    it 'should return table name' do
-      relation.send(:hydra_ref_table, 'code').should == 'hydra_string_attributes'
-    end
-  end
-
-  describe '#hydra_ref_alias' do
-    before do
-      module HydraAttribute
-        class StringAttribute
-          def self.table_name
-            'hydra_string_attributes'
-          end
-        end
-      end
-    end
-
-    after { HydraAttribute.send :remove_const, :StringAttribute }
-
-    describe 'value is nil' do
-      let(:value) { nil }
-
-      it 'should return generated alias name' do
-        relation.send(:hydra_ref_alias, 'code', value).should == 'hydra_string_attributes_left_code'
-      end
-    end
-
-    describe 'value is not nil' do
-      let(:value) { '' }
-
-      it 'should return generated alias name' do
-        relation.send(:hydra_ref_alias, 'code', value).should == 'hydra_string_attributes_inner_code'
-      end
-    end
-  end
-
-  describe '#hydra_join_type' do
-    describe 'value is nil' do
-      let(:value) { nil }
-
-      it 'should return "LEFT"' do
-        relation.send(:hydra_join_type, value).should == 'LEFT'
-      end
-    end
-
-    describe 'value is not nil' do
-      let(:value) { '' }
-
-      it 'should return "INNER"' do
-        relation.send(:hydra_join_type, value).should == 'INNER'
-      end
-    end
-  end
-end
-
-describe HydraAttribute::ActiveRecord::Relation::QueryMethods::Helper do
-  let(:relation_class) do
-    mock(table_name: 'entities', quoted_table_name: '"entities"')
-  end
-
-  let(:connection) do
-    mock_connection = mock
-    mock_connection.stub(:quote_column_name) { |column| %Q("#{column}") }
-    mock_connection
-  end
-
-  let(:relation) do
-    mock(klass: relation_class, connection: connection)
-  end
-
-  let(:helper) do
-    HydraAttribute::ActiveRecord::Relation::QueryMethods::Helper.new(relation)
-  end
-
-  describe '#prepend_table_name' do
-    describe 'param is Symbol' do
-      it 'should prepend table name and quote param' do
-        helper.prepend_table_name(:column).should == '"entities"."column"'
-      end
-    end
-
-    describe 'param is String' do
-      describe 'params is a word character (letter, number, underscore)' do
-        it 'should prepend table name and quote param' do
-          helper.prepend_table_name('abc').should == '"entities"."abc"'
-          helper.prepend_table_name('a_c').should == '"entities"."a_c"'
-          helper.prepend_table_name('a1c').should == '"entities"."a1c"'
-          helper.prepend_table_name(' a ').should == '"entities"."a"'
-        end
-      end
-
-      describe 'params is not a word character (letter, number, underscore)' do
-        it 'should return current string' do
-          helper.prepend_table_name('a c').should == 'a c'
-          helper.prepend_table_name('a-c').should == 'a-c'
-          helper.prepend_table_name('(a)').should == '(a)'
-          helper.prepend_table_name('.').should   == '.'
-        end
-      end
-    end
-  end
-end

data/spec/hydra_attribute/active_record/relation_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-describe HydraAttribute::ActiveRecord::Relation do
-
-  let(:record_class) do
-    mock(:record_class, hydra_attribute_types: [:string], hydra_attribute_names: %w(code), hydra_attributes: {'code' => :string})
-  end
-
-  let(:record) do
-    mock(:record, class: record_class, association: mock(loaded?: false))
-  end
-
-  let(:loaded_record) do
-    mock(:loaded_record, class: record_class, association: mock(loaded?: true))
-  end
-
-  let(:exec_method) do
-    ::ActiveRecord::VERSION::STRING.start_with?('3.1.') ? :to_a : :exec_queries
-  end
-
-  let(:relation) do
-    mock_relation = mock(:relation, loaded?: false, select_values: [], hydra_select_values: [])
-
-    mock_relation.stub(exec_method).and_return(records)
-    mock_relation.stub(:klass).and_return(records.first.class)
-    mock_relation.stub(:where).and_return(mock_relation)
-    mock_relation
-  end
-
-  let(:records) do
-    [record]
-  end
-
-  before do
-    relation.singleton_class.send(:include, HydraAttribute::ActiveRecord::Relation)
-  end
-
-  describe "#exec_queries" do
-    describe 'parent method return one record' do
-      it 'should return one record' do
-        relation.send(exec_method).should have(1).record
-      end
-    end
-
-    describe 'parent method returns two records' do
-      describe 'association models are already loaded' do
-        let(:records) { [loaded_record, loaded_record] }
-
-        it 'should return two record' do
-          relation.send(exec_method).should have(2).records
-        end
-      end
-
-      describe 'association models are not yet loaded' do
-        let(:records) { [record, record] }
-
-        before do
-          ::ActiveRecord::Associations::Preloader.should_receive(:new).with(records, :hydra_string_attributes).and_return(mock(run: records))
-        end
-
-        it 'should return two record' do
-          relation.send(exec_method).should have(2).records
-        end
-      end
-    end
-  end
-end

data/spec/hydra_attribute/active_record/scoping_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-describe HydraAttribute::ActiveRecord::Scoping do
-  describe '#scoped' do
-    let(:ancestor) do
-      method   = ::ActiveRecord::VERSION::STRING.starts_with?('3.1.') ? :to_a : :exec_queries
-      instance = mock(:instance_relation, where: nil, method => nil)
-
-      Module.new do
-        define_method :scoped do |*|
-          instance
-        end
-      end
-    end
-
-    let(:klass) { Class.new.extend(ancestor) }
-
-    it 'should return ActiveRecord::Relation object with extended HydraAttribute::ActiveRecord::Relation module' do
-      klass.send :include, HydraAttribute::ActiveRecord::Scoping
-      klass.scoped.singleton_class.ancestors.should include(HydraAttribute::ActiveRecord::Relation)
-    end
-  end
-end

data/spec/hydra_attribute/active_record_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe HydraAttribute::ActiveRecord do
-  let(:klass) { Class.new.extend(HydraAttribute::ActiveRecord) }
-
-  describe '#define_hydra_attributes' do
-    it 'should yield block in builder scope' do
-      klass.define_hydra_attributes do
-        self.class.should == HydraAttribute::Builder
-      end
-    end
-
-    it 'should include HydraAttribute::ActiveRecord::Scoping to class' do
-      klass.define_hydra_attributes {}
-      klass.should include(HydraAttribute::ActiveRecord::Scoping)
-    end
-  end
-end

data/spec/hydra_attribute/association_builder_spec.rb

@@ -1,95 +0,0 @@
-require 'spec_helper'
-
-describe HydraAttribute::AssociationBuilder do
-  def remove_association
-    [::HydraAttribute, ::Object].each do |klass|
-      klass.send(:remove_const, :StringAttribute) if klass.constants.include?(:StringAttribute)
-    end
-  end
-
-  after(:each) { remove_association }
-
-  let(:klass) do
-    Class.new do
-      @reflection = {}
-      define_singleton_method :reflect_on_association do |assoc|
-        @reflection[assoc]
-      end
-      define_singleton_method :has_many do |assoc, options|
-        @reflection[assoc] = options
-      end
-    end
-  end
-
-  let(:type)        { :string }
-  let(:association) { HydraAttribute::AssociationBuilder.new(klass, type) }
-
-  describe '#buld' do
-    it 'should call #build_associated_model and build_association' do
-      association.should_receive(:create_associated_model)
-      association.should_receive(:add_association_for_class)
-      association.build
-    end
-  end
-
-  describe '#create_associated_model' do
-    describe 'use namespace for associated models' do
-      it 'should create new model' do
-        association.send(:create_associated_model)
-        HydraAttribute.should be_const_defined(:StringAttribute)
-      end
-    end
-
-    describe 'should not use namespace for associated models' do
-      before { HydraAttribute.config.use_module_for_associated_models = false }
-      after  { HydraAttribute.config.use_module_for_associated_models = true  }
-
-      it 'should create new model' do
-        association.send(:create_associated_model)
-        Object.should be_const_defined(:StringAttribute)
-      end
-    end
-
-    describe 'do not try to create twice the same class' do
-      it 'should not warn "already initialized constant"' do
-        association.send(:create_associated_model)
-        HydraAttribute.should_not_receive(:const_set)
-        association.send(:create_associated_model)
-      end
-    end
-
-    describe 'set correct table name' do
-      it 'should be :hydra_string_attributes' do
-        association.send(:create_associated_model)
-        HydraAttribute::StringAttribute.table_name.should == 'hydra_string_attributes'
-      end
-    end
-
-    describe 'set correct belongs_to' do
-      it 'should be polymorphic association' do
-        association.send(:create_associated_model)
-        reflection = HydraAttribute::StringAttribute.reflect_on_association(:entity)
-        reflection.macro.should == :belongs_to
-        reflection.options[:polymorphic].should be_true
-        reflection.options[:touch].should be_true
-        reflection.options[:autosave].should be_true
-      end
-    end
-  end
-
-  describe '#add_association_for_class' do
-    it 'should add has_many association for class' do
-      association.send(:add_association_for_class)
-      reflection = klass.reflect_on_association(:hydra_string_attributes)
-      reflection[:as].should  == :entity
-      reflection[:class_name].should == 'HydraAttribute::StringAttribute'
-      reflection[:autosave].should be_true
-    end
-
-    it 'should not add twice the same has_many association' do
-      association.send(:add_association_for_class)
-      klass.should_not_receive(:has_many)
-      association.send(:add_association_for_class)
-    end
-  end
-end

data/spec/hydra_attribute/attribute_builder_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-describe HydraAttribute::AttributeBuilder do
-  let(:klass)     { Class.new }
-  let(:attribute) { HydraAttribute::AttributeBuilder.new(klass, :name, :string) }
-
-  describe '#build' do
-    it 'should call required methods' do
-      attribute.should_receive(:define_attribute_methods)
-      attribute.should_receive(:save_attribute)
-      attribute.build
-    end
-  end
-
-  describe '#define_attribute_methods' do
-    let(:matcher_get) do
-      mock_matcher = mock
-      mock_matcher.stub(:method_name) { |value| value.to_s }
-      mock_matcher
-    end
-
-    let(:matcher_set) do
-      mock_matcher = mock
-      mock_matcher.stub(:method_name) { |value| "#{value}=" }
-      mock_matcher
-    end
-
-    let(:matcher_query) do
-      mock_matcher = mock
-      mock_matcher.stub(:method_name) { |value| "#{value}?" }
-      mock_matcher
-    end
-
-    before do
-      klass.stub(attribute_method_matchers: [matcher_get, matcher_set, matcher_query])
-      attribute.send(:define_attribute_methods)
-    end
-
-    it 'should respond to #name' do
-      klass.new.should respond_to(:name)
-    end
-
-    it 'should respond to #name=' do
-      klass.new.should respond_to(:name=)
-    end
-
-    it 'should respond to #name?' do
-      klass.new.should respond_to(:name?)
-    end
-
-    it 'should define all methods in module' do
-      [:name, :name=, :name?].each do |method|
-        klass.new.method(method).owner.class.should == Module
-      end
-    end
-  end
-
-  describe '#store_attribute' do
-    before do
-      attribute.instance_variable_set(:@name, :name)
-      attribute.instance_variable_set(:@type, :type)
-      klass.instance_variable_set(:@hydra_attributes, {})
-    end
-
-    it 'should save attribute name and type in @hydra_attributes' do
-      attribute.send(:save_attribute)
-      klass.instance_variable_get(:@hydra_attributes)[:name].should == :type
-    end
-  end
-end

data/spec/hydra_attribute/attribute_helpers_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-__END__
-describe HydraAttribute::AttributeHelpers do
-  let(:klass) { Class.new { include HydraAttribute::AttributeHelpers } }
-
-  describe '.inherited' do
-    it 'should clone @hydra_attributes to base class' do
-      klass.instance_variable_set(:@hydra_attributes, {a: 1, b: 2})
-      sub_class = Class.new(klass)
-      sub_class.instance_variable_get(:@hydra_attributes).should == {a: 1, b: 2}
-      sub_class.instance_variable_get(:@hydra_attributes).should_not equal(klass.instance_variable_get(:@hydra_attributes))
-    end
-  end
-
-  describe '.hydra_attributes' do
-    it 'should return hash of attributes' do
-      klass.hydra_attributes.should == {}
-    end
-
-    it 'should return cloned hash' do
-      klass.hydra_attributes.should_not equal(klass.hydra_attributes)
-    end
-  end
-
-  describe '.hydra_attribute_names' do
-    it 'should return hash keys' do
-      klass.instance_variable_set(:@hydra_attributes, {a: 1, b: 2})
-      klass.hydra_attribute_names.should == [:a, :b]
-    end
-  end
-
-  describe '.hydra_attribute_types' do
-    it 'should return hash values' do
-      klass.instance_variable_set(:@hydra_attributes, {a: 1, b: 2})
-      klass.hydra_attribute_types.should == [1, 2]
-    end
-  end
-
-  describe '#hydra_attribute_model' do
-    let(:code_model)  { mock(name: :code) }
-    let(:title_model) { mock(name: :title) }
-    let(:collection)  { [code_model, title_model] }
-
-    before do
-      HydraAttribute.config.should_receive(:association).with(:string).and_return(:string_association)
-      klass.any_instance.should_receive(:string_association).and_return(collection)
-    end
-
-    describe 'type collection has built model' do
-      let(:name) { :code }
-
-      it 'should return model' do
-        klass.new.hydra_attribute_model(name, :string).should == code_model
-      end
-    end
-
-    describe 'type collection has not built model' do
-      let(:name)  { :price }
-      let(:built) { mock(:built) }
-
-      before do
-        collection.should_receive(:build).with(name: :price).and_return(built)
-      end
-
-      it 'should build model' do
-        klass.new.hydra_attribute_model(name, :string).should == built
-      end
-    end
-  end
-end