hydra_attribute 0.1.0

data/spec/hydra_attribute/active_record/relation_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe HydraAttribute::ActiveRecord::Relation do
+  def record_class(loaded_associations = false)
+    Class.new do
+
+      @hydra_attributes = {'code' => :string}
+      define_singleton_method :hydra_attribute_types do
+        [:string]
+      end
+
+      define_singleton_method :hydra_attribute_names do
+        ['code']
+      end
+
+      define_singleton_method :hydra_attributes do
+        @hydra_attributes
+      end
+
+      define_method :association do |_|
+        Class.new do
+          define_singleton_method :loaded? do
+            loaded_associations
+          end
+        end
+      end
+    end
+  end
+
+  def relation_function(records)
+    Module.new do
+      define_method :loaded? do
+        false
+      end
+
+      define_method :select_values do
+        []
+      end
+
+      define_method :hydra_select_values do
+        []
+      end
+
+      define_method HydraAttribute.config.relation_execute_method do
+        records
+      end
+
+      define_method :klass do
+        records.first.class
+      end
+
+      define_method :where do |*|
+        self
+      end
+    end
+  end
+
+  let(:records)  { [record_class.new] }
+  let(:ancestor) { relation_function(records) }
+  let(:klass)    { Class.new.extend(ancestor).extend(HydraAttribute::ActiveRecord::Relation) }
+
+  describe "##{HydraAttribute.config.relation_execute_method}" do
+    describe 'parent method return one record' do
+      it 'should return one record' do
+        klass.send(HydraAttribute.config.relation_execute_method).should have(1).record
+      end
+    end
+
+    describe 'parent method returns two records' do
+      let(:records) { [record_class(loaded_associations).new, record_class(loaded_associations).new] }
+
+      describe 'association models are already loaded' do
+        let(:loaded_associations) { true }
+
+        it 'should return two record' do
+          klass.send(HydraAttribute.config.relation_execute_method).should have(2).records
+        end
+      end
+
+      describe 'association models are not yet loaded' do
+        let(:loaded_associations) { false }
+
+        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
+          klass.send(HydraAttribute.config.relation_execute_method).should have(2).records
+        end
+      end
+    end
+  end
+end

data/spec/hydra_attribute/active_record/scoping_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe HydraAttribute::ActiveRecord::Scoping do
+  describe '#scoped' do
+    let(:ancestor) do
+      Module.new do
+        def scoped(*) self end
+        def where(*) self 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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe HydraAttribute::ActiveRecord do
+  let(:klass) { Class.new.extend(HydraAttribute::ActiveRecord) }
+
+  describe '#define_hydra_attributes' do
+    let(:builder) { @builder }
+    before        { klass.define_hydra_attributes { |b| @builder = b } }
+
+    it 'should yield block with preconfigured current class' do
+      builder.should be_an_instance_of(HydraAttribute::Builder)
+      builder.klass.should be_equal(klass)
+
+    end
+
+    it 'should include HydraAttribute::ActiveRecord::Scoping to class' do
+      klass.should include(HydraAttribute::ActiveRecord::Scoping)
+    end
+  end
+end

data/spec/hydra_attribute/association_builder_spec.rb

@@ -0,0 +1,95 @@
+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

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,70 @@
+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

data/spec/hydra_attribute/builder_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe HydraAttribute::Builder do
+
+  let(:klass)    { Class.new }
+  let!(:builder) { HydraAttribute::Builder.new(klass) }
+
+  describe '#initialzie' do
+    it 'should include HydraAttribute::ActiveRecord::Scoping to class' do
+      klass.should include(HydraAttribute::ActiveRecord::Scoping)
+    end
+
+    it 'should include HydraAttribute::ActiveRecord::AttributeMethods to class' do
+      klass.should include(HydraAttribute::ActiveRecord::AttributeMethods)
+    end
+
+    it 'should respond to all supported types' do
+      HydraAttribute::SUPPORT_TYPES.each do |type|
+        builder.should respond_to(type)
+      end
+    end
+  end
+
+  describe '#string' do
+    let(:association_instance) { mock(:association_instance) }
+    let(:attribute_instance)   { mock(:attribute_instance) }
+
+    before do
+      HydraAttribute::AssociationBuilder.should_receive(:new).with(klass, :string).and_return(association_instance)
+      HydraAttribute::AttributeBuilder.should_receive(:new).with(klass, :name, :string).and_return(attribute_instance)
+
+      [association_instance, attribute_instance].each { |instance| instance.should_receive(:build) }
+    end
+
+    it 'should build association' do
+      builder.string :name
+    end
+  end
+end

data/spec/hydra_attribute/configuration_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe HydraAttribute::Configuration do
+  let(:config) { HydraAttribute::Configuration.new }
+
+  describe '#table_name' do
+    describe 'with table prefix' do
+      before { config.table_prefix = 'table_' }
+
+      it 'should return table name' do
+        config.table_name(:string).should == :table_string_attributes
+      end
+    end
+
+    describe 'without table prefix' do
+      before { config.table_prefix = '' }
+
+      it 'should return table name' do
+        config.table_name(:string).should == :string_attributes
+      end
+    end
+  end
+
+  describe '#association' do
+    describe 'with association prefix' do
+      before { config.association_prefix = 'assoc_' }
+
+      it 'should return association name' do
+        config.association(:string).should == :assoc_string_attributes
+      end
+    end
+
+    describe 'without association prefix' do
+      before { config.association_prefix = '' }
+
+      it 'should return association name' do
+        config.association(:string).should == :string_attributes
+      end
+    end
+  end
+
+  describe '#associated_model_name' do
+    describe 'use module wrapper' do
+      before { config.use_module_for_associated_models = true }
+
+      it 'should return associated model name' do
+        config.associated_model_name(:string).should == 'HydraAttribute::StringAttribute'
+      end
+    end
+
+    describe 'don not use module wrapper' do
+      before { config.use_module_for_associated_models = false }
+
+      it 'should return associated model name' do
+        config.associated_model_name(:string).should == 'StringAttribute'
+      end
+    end
+  end
+
+  describe '#associated_const_name' do
+    it 'should return constant name for new model' do
+      config.associated_const_name(:string).should == :StringAttribute
+    end
+  end
+
+  describe '#relation_execute_method' do
+    after do
+      ::ActiveRecord::VERSION.send(:remove_const, :MINOR)
+      ::ActiveRecord::VERSION.const_set(:MINOR, @old_value)
+    end
+
+    describe 'ActiveRecord::VERSION::MINOR is great than 1' do
+      before do
+        @old_value = ::ActiveRecord::VERSION::MINOR
+        ::ActiveRecord::VERSION.send(:remove_const, :MINOR)
+        ::ActiveRecord::VERSION.const_set(:MINOR, 2)
+      end
+
+      it 'should return :exec_queries' do
+        config.relation_execute_method.should == :exec_queries
+      end
+    end
+
+    describe 'ActiveRecord::VERSION::MINOR is less than or equal 1' do
+      before do
+        @old_value = ::ActiveRecord::VERSION::MINOR
+        ::ActiveRecord::VERSION.send(:remove_const, :MINOR)
+        ::ActiveRecord::VERSION.const_set(:MINOR, 1)
+      end
+
+      it 'should return :to_a' do
+        config.relation_execute_method.should == :to_a
+      end
+    end
+  end
+end