active_data 0.3.0 → 1.0.0

data/spec/lib/active_data/model/attributes_spec.rb

@@ -0,0 +1,243 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe ActiveData::Model::Attributes do
+  let(:model) do
+    stub_model do
+      include ActiveData::Model::Associations
+      include ActiveData::Model::Localization
+
+      attribute :id, Integer
+      attribute :full_name, String
+      alias_attribute :name, :full_name
+
+      localized :t, String
+      alias_attribute :title, :t
+
+      embeds_one(:author) {}
+      embeds_many(:projects) {}
+    end
+  end
+
+  describe '.reflect_on_attribute' do
+    specify { expect(model.reflect_on_attribute(:full_name).name).to eq('full_name') }
+    specify { expect(model.reflect_on_attribute('full_name').name).to eq('full_name') }
+    specify { expect(model.reflect_on_attribute(:name).name).to eq('full_name') }
+    specify { expect(model.reflect_on_attribute(:foobar)).to be_nil }
+  end
+
+  describe '.has_attribute?' do
+    specify { expect(model.has_attribute?(:full_name)).to eq(true) }
+    specify { expect(model.has_attribute?('full_name')).to eq(true) }
+    specify { expect(model.has_attribute?(:name)).to eq(true) }
+    specify { expect(model.has_attribute?(:foobar)).to eq(false) }
+  end
+
+  describe '.attribute_names' do
+    specify { expect(stub_model.attribute_names).to eq([])  }
+    specify { expect(model.attribute_names).to eq(%w[id full_name t author projects]) }
+    specify { expect(model.attribute_names(false)).to eq(%w[id full_name t])  }
+  end
+
+  describe '.inspect' do
+    specify { expect(stub_model.inspect).to match(/#<Class:0x\w+>\(no attributes\)/) }
+    specify { expect(stub_model(:user).inspect).to eq('User(no attributes)') }
+    specify { expect(stub_model {
+      include ActiveData::Model::Primary
+      primary :count, Integer
+      attribute :object, Object
+    }.inspect).to match(/#<Class:0x\w+>\(\*count: Integer, object: Object\)/) }
+    specify { expect(stub_model(:user) {
+      include ActiveData::Model::Primary
+      primary :count, Integer
+      attribute :object, Object
+    }.inspect).to match('User(*count: Integer, object: Object)') }
+  end
+
+  describe '#==' do
+    let(:model) do
+      stub_model do
+        attribute :name, String
+        attribute :count, Float, default: 0
+      end
+    end
+    subject { model.new name: 'hello', count: 42 }
+
+    it { is_expected.not_to eq(nil) }
+    it { is_expected.not_to eq('hello') }
+    it { is_expected.not_to eq(Object.new) }
+    it { is_expected.not_to eq(model.new) }
+    it { is_expected.not_to eq(model.new(name: 'hello1', count: 42)) }
+    it { is_expected.not_to eq(model.new(name: 'hello', count: 42.1)) }
+    it { is_expected.to eq(model.new(name: 'hello', count: 42)) }
+
+    it { is_expected.not_to eql(nil) }
+    it { is_expected.not_to eql('hello') }
+    it { is_expected.not_to eql(Object.new) }
+    it { is_expected.not_to eql(model.new) }
+    it { is_expected.not_to eql(model.new(name: 'hello1', count: 42)) }
+    it { is_expected.not_to eql(model.new(name: 'hello', count: 42.1)) }
+    it { is_expected.to eql(model.new(name: 'hello', count: 42)) }
+  end
+
+  describe '#attribute' do
+    let(:instance) { model.new }
+    specify { expect(instance.attribute(:full_name).reflection.name).to eq('full_name') }
+    specify { expect(instance.attribute('full_name').reflection.name).to eq('full_name') }
+    specify { expect(instance.attribute(:name).reflection.name).to eq('full_name') }
+    specify { expect(instance.attribute(:foobar)).to be_nil }
+
+    specify { expect(instance.attribute('full_name')).to equal(instance.attribute(:name)) }
+  end
+
+  describe '#has_attribute?' do
+    specify { expect(model.new.has_attribute?(:full_name)).to eq(true) }
+    specify { expect(model.new.has_attribute?('full_name')).to eq(true) }
+    specify { expect(model.new.has_attribute?(:name)).to eq(true) }
+    specify { expect(model.new.has_attribute?(:foobar)).to eq(false) }
+  end
+
+  describe '#attribute_names' do
+    specify { expect(stub_model.new.attribute_names).to eq([])  }
+    specify { expect(model.new.attribute_names).to eq(%w[id full_name t author projects]) }
+    specify { expect(model.new.attribute_names(false)).to eq(%w[id full_name t])  }
+  end
+
+  describe '#attribute_present?' do
+    specify { expect(model.new.attribute_present?(:name)).to be(false) }
+    specify { expect(model.new(name: '').attribute_present?(:name)).to be(false) }
+    specify { expect(model.new(name: 'Name').attribute_present?(:name)).to be(true) }
+  end
+
+  describe '#attributes' do
+    specify { expect(stub_model.new.attributes).to eq({})  }
+    specify { expect(model.new(name: 'Name').attributes)
+      .to match({'id' => nil, 'full_name' => 'Name', 't' => {}, 'author' => nil, 'projects' => nil})  }
+    specify { expect(model.new(name: 'Name').attributes(false))
+      .to match({'id' => nil, 'full_name' => 'Name', 't' => {}})  }
+  end
+
+  describe '#assign_attributes' do
+    let(:attributes) { { id: 42, full_name: 'Name', missed: 'value' } }
+    subject { model.new }
+
+    specify { expect { subject.assign_attributes(attributes) }.to change { subject.id }.to(42) }
+    specify { expect { subject.assign_attributes(attributes) }.to change { subject.full_name }.to('Name') }
+  end
+
+  describe '#inspect' do
+    specify { expect(stub_model.new.inspect).to match(/#<#<Class:0x\w+> \(no attributes\)>/) }
+    specify { expect(stub_model(:user).new.inspect).to match(/#<User \(no attributes\)>/) }
+    specify { expect(stub_model {
+      include ActiveData::Model::Primary
+      primary :count, Integer
+      attribute :object, Object
+    }.new(object: 'String').inspect).to match(/#<#<Class:0x\w+> \*count: nil, object: "String">/) }
+    specify { expect(stub_model(:user) {
+      include ActiveData::Model::Primary
+      primary :count, Integer
+      attribute :object, Object
+    }.new.inspect).to match(/#<User \*count: nil, object: nil>/) }
+  end
+
+  context 'attributes integration' do
+    let(:model) do
+      stub_class do
+        include ActiveData::Model::Attributes
+        include ActiveData::Model::Associations
+        attr_accessor :name
+
+        attribute :id, Integer
+        attribute :hello, Object
+        attribute :string, String, default: ->(record){ record.name }
+        attribute :count, Integer, default: '10'
+        attribute(:calc, Integer) { 2 + 3 }
+        attribute :enum, Integer, enum: [1, 2, 3]
+        attribute :enum_with_default, Integer, enum: [1, 2, 3], default: '2'
+        attribute :foo, Boolean, default: false
+        collection :array, Integer, enum: [1, 2, 3], default: 7
+
+        def initialize name = nil
+          super()
+          @name = name
+        end
+      end
+    end
+
+    subject { model.new('world') }
+
+    its(:enum_values) { should == [1, 2, 3] }
+    its(:string_default) { should == 'world' }
+    its(:count_default) { should == '10' }
+    its(:name) { should == 'world' }
+    its(:hello) { should eq(nil) }
+    its(:hello?) { should eq(false) }
+    its(:count) { should == 10 }
+    its(:count_before_type_cast) { should == '10' }
+    its(:count?) { should eq(true) }
+    its(:calc) { should == 5 }
+    its(:enum?) { should eq(false) }
+    its(:enum_with_default?) { should eq(true) }
+    specify { expect { subject.hello = 'worlds' }.to change { subject.hello }.from(nil).to('worlds') }
+    specify { expect { subject.count = 20 }.to change { subject.count }.from(10).to(20) }
+    specify { expect { subject.calc = 15 }.to change { subject.calc }.from(5).to(15) }
+
+    context 'enums' do
+      specify { subject.enum = 3; expect(subject.enum).to eq(3) }
+      specify { subject.enum = '3'; expect(subject.enum).to eq(3) }
+      specify { subject.enum = 10; expect(subject.enum).to eq(nil) }
+      specify { subject.enum = 'hello'; expect(subject.enum).to eq(nil) }
+      specify { subject.enum_with_default = 3; expect(subject.enum_with_default).to eq(3) }
+      specify { subject.enum_with_default = 10; expect(subject.enum_with_default).to be_nil }
+    end
+
+    context 'array' do
+      specify { subject.array = [2, 4]; expect(subject.array).to eq([2, nil]) }
+      specify { subject.array = [2, 4]; expect(subject.array?).to eq(true) }
+      specify { subject.array = [2, 4]; expect(subject.array_values).to eq([1, 2, 3]) }
+      specify { subject.array = [2, 4]; expect(subject.array_default).to eq(7) }
+    end
+
+    context 'attribute caching' do
+      before do
+        subject.hello = 'blabla'
+        subject.hello
+        subject.hello = 'newnewnew'
+      end
+
+      specify { expect(subject.hello).to eq('newnewnew') }
+    end
+  end
+
+  context 'inheritance' do
+    let!(:ancestor) do
+      Class.new do
+        include ActiveData::Model::Attributes
+        attribute :foo, String
+      end
+    end
+
+    let!(:descendant1) do
+      Class.new ancestor do
+        attribute :bar, String
+      end
+    end
+
+    let!(:descendant2) do
+      Class.new ancestor do
+        attribute :baz, String
+        attribute :moo, String
+      end
+    end
+
+    specify { expect(ancestor._attributes.keys).to eq(['foo']) }
+    specify { expect(ancestor.instance_methods).to include :foo, :foo= }
+    specify { expect(ancestor.instance_methods).not_to include :bar, :bar=, :baz, :baz= }
+    specify { expect(descendant1._attributes.keys).to eq(['foo', 'bar']) }
+    specify { expect(descendant1.instance_methods).to include :foo, :foo=, :bar, :bar= }
+    specify { expect(descendant1.instance_methods).not_to include :baz, :baz= }
+    specify { expect(descendant2._attributes.keys).to eq(['foo', 'baz', 'moo']) }
+    specify { expect(descendant2.instance_methods).to include :foo, :foo=, :baz, :baz=, :moo, :moo= }
+    specify { expect(descendant2.instance_methods).not_to include :bar, :bar= }
+  end
+end

data/spec/lib/active_data/model/callbacks_spec.rb

@@ -0,0 +1,338 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe ActiveData::Model::Callbacks do
+  before do
+    stub_model(:user) do
+      include ActiveData::Model::Callbacks
+      attribute :actions, Array, default: []
+
+      def append action
+        self.actions = actions + [action]
+      end
+
+      define_create { append :create }
+      define_update { append :update }
+      define_destroy { append :destroy }
+    end
+  end
+
+  describe '.after_initialize' do
+    before do
+      User.after_initialize { append :after_initialize }
+    end
+
+    specify { expect(User.new.actions).to eq([:after_initialize]) }
+    specify { expect(User.create.actions).to eq([:after_initialize, :create]) }
+  end
+
+  describe '.before_save, .after_save' do
+    before do
+      User.before_save { append :before_save }
+      User.after_save { append :after_save }
+    end
+
+    specify { expect(User.create.actions).to eq([:before_save, :create, :after_save]) }
+    specify { expect(User.new.tap(&:save).actions).to eq([:before_save, :create, :after_save]) }
+    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq([:before_save, :create, :after_save]) }
+    specify { expect(User.create.tap(&:save).actions).to eq([:before_save, :create, :after_save, :before_save, :update, :after_save]) }
+    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq([:before_save, :create, :after_save, :before_save, :update, :after_save]) }
+
+    specify { expect(User.new.tap { |u| u.save { false } }.actions).to eq([:before_save]) }
+    specify { expect(User.create.tap { |u| u.save { false } }.actions).to eq([:before_save, :create, :after_save, :before_save]) }
+  end
+
+  describe '.around_save' do
+    before do
+      User.around_save do |user, block|
+        append :before_around_save
+        block.call
+        append :after_around_save
+      end
+    end
+
+    specify { expect(User.create.actions).to eq([:before_around_save, :create, :after_around_save]) }
+    specify { expect(User.new.tap(&:save).actions).to eq([:before_around_save, :create, :after_around_save]) }
+    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq([:before_around_save, :create, :after_around_save]) }
+    specify { expect(User.create.tap(&:save).actions).to eq([:before_around_save, :create, :after_around_save, :before_around_save, :update, :after_around_save]) }
+    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq([:before_around_save, :create, :after_around_save, :before_around_save, :update, :after_around_save]) }
+
+    specify { expect(User.new.tap { |u| u.save { false } }.actions).to eq([:before_around_save, :after_around_save]) }
+    specify { expect(User.create.tap { |u| u.save { false } }.actions).to eq([:before_around_save, :create, :after_around_save, :before_around_save, :after_around_save]) }
+  end
+
+  describe '.before_create, .after_create' do
+    before do
+      User.before_create { append :before_create }
+      User.after_create { append :after_create }
+    end
+
+    specify { expect(User.create.actions).to eq([:before_create, :create, :after_create]) }
+    specify { expect(User.new.tap(&:save).actions).to eq([:before_create, :create, :after_create]) }
+    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq([:before_create, :create, :after_create]) }
+    specify { expect(User.create.tap(&:save).actions).to eq([:before_create, :create, :after_create, :update]) }
+    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq([:before_create, :create, :after_create, :update]) }
+
+    specify { expect(User.new.tap { |u| u.save { false } }.actions).to eq([:before_create]) }
+  end
+
+  describe '.around_create' do
+    before do
+      User.around_create do |user, block|
+        append :before_around_create
+        block.call
+        append :after_around_create
+      end
+    end
+
+    specify { expect(User.create.actions).to eq([:before_around_create, :create, :after_around_create]) }
+    specify { expect(User.new.tap(&:save).actions).to eq([:before_around_create, :create, :after_around_create]) }
+    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq([:before_around_create, :create, :after_around_create]) }
+    specify { expect(User.create.tap(&:save).actions).to eq([:before_around_create, :create, :after_around_create, :update]) }
+    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq([:before_around_create, :create, :after_around_create, :update]) }
+
+    specify { expect(User.new.tap { |u| u.save { false } }.actions).to eq([:before_around_create, :after_around_create]) }
+  end
+
+  describe '.before_update, .after_update' do
+    before do
+      User.before_update { append :before_update }
+      User.after_update { append :after_update }
+    end
+
+    specify { expect(User.create.actions).to eq([:create]) }
+    specify { expect(User.new.tap(&:save).actions).to eq([:create]) }
+    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq([:create]) }
+    specify { expect(User.create.tap(&:save).actions).to eq([:create, :before_update, :update, :after_update]) }
+    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq([:create, :before_update, :update, :after_update]) }
+
+    specify { expect(User.create.tap { |u| u.save { false } }.actions).to eq([:create, :before_update]) }
+  end
+
+  describe '.around_update' do
+    before do
+      User.around_update do |user, block|
+        append :before_around_update
+        block.call
+        append :after_around_update
+      end
+    end
+
+    specify { expect(User.create.actions).to eq([:create]) }
+    specify { expect(User.new.tap(&:save).actions).to eq([:create]) }
+    specify { expect(User.new.tap { |u| u.update({}) }.actions).to eq([:create]) }
+    specify { expect(User.create.tap(&:save).actions).to eq([:create, :before_around_update, :update, :after_around_update]) }
+    specify { expect(User.create.tap { |u| u.update({}) }.actions).to eq([:create, :before_around_update, :update, :after_around_update]) }
+
+    specify { expect(User.create.tap { |u| u.save { false } }.actions).to eq([:create, :before_around_update, :after_around_update]) }
+  end
+
+  describe '.before_validation, .after_validation,
+            .before_save, .after_save, .around_save,
+            .before_create, .after_create, .around_create,
+            .before_update, .after_update, .around_update
+            .before_destroy, .after_destroy, .around_destroy' do
+    before do
+      User.before_validation { append :before_validation }
+      User.after_validation { append :after_validation }
+
+      User.before_save { append :before_save }
+      User.after_save { append :after_save }
+      User.around_save do |user, block|
+        append :before_around_save
+        block.call
+        append :after_around_save
+      end
+
+      User.before_create { append :before_create }
+      User.after_create { append :after_create }
+      User.around_create do |user, block|
+        append :before_around_create
+        block.call
+        append :after_around_create
+      end
+
+      User.before_update { append :before_update }
+      User.after_update { append :after_update }
+      User.around_update do |user, block|
+        append :before_around_update
+        block.call
+        append :after_around_update
+      end
+
+      User.before_destroy { append :before_destroy }
+      User.after_destroy { append :after_destroy }
+      User.around_destroy do |user, block|
+        append :before_around_destroy
+        block.call
+        append :after_around_destroy
+      end
+    end
+
+    specify { expect(User.create.tap(&:save).destroy.actions).to eq([
+      :before_validation, :after_validation,
+      :before_save, :before_around_save,
+      :before_create, :before_around_create,
+      :create,
+      :after_around_create, :after_create,
+      :after_around_save, :after_save,
+
+      :before_validation, :after_validation,
+      :before_save, :before_around_save,
+      :before_update, :before_around_update,
+      :update,
+      :after_around_update, :after_update,
+      :after_around_save, :after_save,
+
+      :before_destroy, :before_around_destroy,
+      :destroy,
+      :after_around_destroy, :after_destroy
+    ]) }
+  end
+
+  describe '.before_destroy, .after_destroy' do
+    before do
+      User.before_destroy { append :before_destroy }
+      User.after_destroy { append :after_destroy }
+    end
+
+    specify { expect(User.new.destroy.actions).to eq([:before_destroy, :destroy, :after_destroy]) }
+    specify { expect(User.create.destroy.actions).to eq([:create, :before_destroy, :destroy, :after_destroy]) }
+
+    specify { expect(User.new.destroy { false }.actions).to eq([:before_destroy]) }
+    specify { expect(User.create.destroy { false }.actions).to eq([:create, :before_destroy]) }
+  end
+
+  describe '.around_destroy' do
+    before do
+      User.around_destroy do |user, block|
+        append :before_around_destroy
+        block.call
+        append :after_around_destroy
+      end
+    end
+
+    specify { expect(User.new.destroy.actions).to eq([:before_around_destroy, :destroy, :after_around_destroy]) }
+    specify { expect(User.create.destroy.actions).to eq([:create, :before_around_destroy, :destroy, :after_around_destroy]) }
+
+    specify { expect(User.new.destroy { false }.actions).to eq([:before_around_destroy, :after_around_destroy]) }
+    specify { expect(User.create.destroy { false }.actions).to eq([:create, :before_around_destroy, :after_around_destroy]) }
+  end
+
+  context 'unsavable, undestroyable' do
+    before do
+      stub_model(:user) do
+        include ActiveData::Model::Callbacks
+
+        attribute :actions, Array, default: []
+        attribute :validated, Boolean, default: false
+
+        validates :validated, presence: true
+
+        def append action
+          self.actions = actions + [action]
+        end
+      end
+    end
+
+    before do
+      User.before_validation { append :before_validation }
+      User.after_validation { append :after_validation }
+
+      User.before_save { append :before_save }
+      User.after_save { append :after_save }
+      User.around_save do |&block|
+        append :before_around_save
+        block.call
+        append :after_around_save
+      end
+
+      User.before_create { append :before_create }
+      User.after_create { append :after_create }
+      User.around_create do |&block|
+        append :before_around_create
+        block.call
+        append :after_around_create
+      end
+
+      User.before_update { append :before_update }
+      User.after_update { append :after_update }
+      User.around_update do |&block|
+        append :before_around_update
+        block.call
+        append :after_around_update
+      end
+
+      User.before_destroy { append :before_destroy }
+      User.after_destroy { append :after_destroy }
+      User.around_destroy do |&block|
+        append :before_around_destroy
+        block.call
+        append :after_around_destroy
+      end
+    end
+
+    let(:user) { User.new }
+
+    specify do
+      begin
+        user.save
+      rescue ActiveData::UnsavableObject
+        expect(user.actions).to eq([])
+      end
+    end
+
+    specify do
+      begin
+        user.save!
+      rescue ActiveData::UnsavableObject
+        expect(user.actions).to eq([])
+      end
+    end
+
+    specify do
+      user.save { true }
+      expect(user.actions).to eq([:before_validation, :after_validation])
+    end
+
+    specify do
+      begin
+        user.save! { true }
+      rescue ActiveData::ValidationError
+        expect(user.actions).to eq([:before_validation, :after_validation])
+      end
+    end
+
+    specify do
+      begin
+        user.update({})
+      rescue ActiveData::UnsavableObject
+        expect(user.actions).to eq([])
+      end
+    end
+
+    specify do
+      begin
+        user.update!({})
+      rescue ActiveData::UnsavableObject
+        expect(user.actions).to eq([])
+      end
+    end
+
+    specify do
+      begin
+        user.destroy
+      rescue ActiveData::UndestroyableObject
+        expect(user.actions).to eq([])
+      end
+    end
+
+    specify do
+      begin
+        user.destroy!
+      rescue ActiveData::UndestroyableObject
+        expect(user.actions).to eq([])
+      end
+    end
+  end
+end