active_data 0.3.0 → 1.0.0

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

@@ -0,0 +1,47 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe ActiveData::Model::Persistence do
+  let(:model) do
+    stub_model do
+      include ActiveData::Model::Persistence
+
+      attribute :name
+      attribute :count, default: 0
+    end
+  end
+
+  specify { expect(model.new).not_to be_persisted }
+  specify { expect(model.new).not_to be_destroyed }
+
+  describe '#instantiate' do
+    specify { expect(model.instantiate({})).to be_an_instance_of model }
+    specify { expect(model.instantiate({})).to be_persisted }
+    specify { expect(model.instantiate({})).not_to be_destroyed }
+
+    context do
+      subject(:instance) { model.instantiate(name: 'Hello', foo: 'Bar') }
+
+      specify { expect(subject.instance_variable_get(:@initial_attributes)).to eq({ name: 'Hello' }.stringify_keys) }
+    end
+  end
+
+  describe '#instantiate_collection' do
+    context do
+      subject(:instances) { model.instantiate_collection(name: 'Hello', foo: 'Bar') }
+
+      specify { expect(subject).to be_a Array }
+      specify { expect(subject.first.instance_variable_get(:@initial_attributes)).to eq({ name: 'Hello' }.stringify_keys) }
+    end
+
+    context do
+      before { model.send(:include, ActiveData::Model::Scopes) }
+      subject(:instances) { model.instantiate_collection([{ name: 'Hello', foo: 'Bar' }, {name: 'World'}]) }
+
+      specify { expect(subject).to be_a ActiveData::Model::Scopes::ScopeProxy }
+      specify { expect(subject.count).to eq(2) }
+      specify { expect(subject.first.instance_variable_get(:@initial_attributes)).to eq({ name: 'Hello' }.stringify_keys) }
+      specify { expect(subject.second.instance_variable_get(:@initial_attributes)).to eq({ name: 'World' }.stringify_keys) }
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe ActiveData::Model::Primary do
+  context 'undefined' do
+    let(:model) do
+      stub_model do
+        include ActiveData::Model::Primary
+
+        attribute :name, String
+      end
+    end
+
+    specify { expect(model.has_primary_attribute?).to eq(false) }
+    specify { expect(model.new.has_primary_attribute?).to eq(false) }
+    specify { expect { model.new.primary_attribute }.to raise_error NoMethodError }
+    specify { expect(model.new(name: 'Hello')).to eq(model.new(name: 'Hello')) }
+    specify { expect(model.new(name: 'Hello')).to eql(model.new(name: 'Hello')) }
+
+    context do
+      let(:object) { model.new(name: 'Hello') }
+      specify { expect(object).not_to eq(object.clone.tap { |o| o.update(name: 'World') }) }
+      specify { expect(object).not_to eql(object.clone.tap { |o| o.update(name: 'World') }) }
+    end
+  end
+
+  context 'defined' do
+    let(:model) do
+      stub_model do
+        include ActiveData::Model::Primary
+
+        primary_attribute
+        attribute :name, String
+      end
+    end
+
+    specify { expect(model.has_primary_attribute?).to eq(true) }
+    specify { expect(model.new.has_primary_attribute?).to eq(true) }
+    specify { expect(model.new.primary_attribute).to be_a(ActiveData::UUID) }
+    specify { expect(model.new(name: 'Hello')).not_to eq(model.new(name: 'Hello')) }
+    specify { expect(model.new(name: 'Hello')).not_to eql(model.new(name: 'Hello')) }
+    specify { expect(model.new(id: 0).id).not_to eq(ActiveData::UUID.parse_int(0)) }
+    specify { expect(model.new.tap { |o| o.id = 0 }.id).to eq(ActiveData::UUID.parse_int(0)) }
+
+    context do
+      let(:object) { model.new(name: 'Hello') }
+      specify { expect(object).to eq(object.clone.tap { |o| o.update(name: 'World') }) }
+      specify { expect(object).to eql(object.clone.tap { |o| o.update(name: 'World') }) }
+    end
+  end
+
+  context 'defined' do
+    let(:model) do
+      stub_model do
+        include ActiveData::Model::Primary
+
+        primary_attribute type: Integer
+        attribute :name
+      end
+    end
+
+    specify { expect(model.has_primary_attribute?).to eq(true) }
+    specify { expect(model.new.has_primary_attribute?).to eq(true) }
+    specify { expect(model.new.primary_attribute).to be_nil }
+    specify { expect(model.new(name: 'Hello')).not_to eq(model.new(name: 'Hello')) }
+    specify { expect(model.new(name: 'Hello')).not_to eql(model.new(name: 'Hello')) }
+    specify { expect(model.new(name: 'Hello').tap { |o| o.id = 1 }).not_to eq(model.new(name: 'Hello').tap { |o| o.id = 2 }) }
+    specify { expect(model.new(name: 'Hello').tap { |o| o.id = 1 }).not_to eql(model.new(name: 'Hello').tap { |o| o.id = 2 }) }
+    specify { expect(model.new(id: 1).id).to be_nil }
+    specify { expect(model.new.tap { |o| o.assign_attributes(id: 1) }.id).to be_nil }
+    specify { expect(model.new.tap { |o| o.id = 1 }.id).to eq(1) }
+
+    context do
+      let(:object) { model.new(name: 'Hello').tap { |o| o.id = 1 } }
+      specify { expect(object).to eq(object.clone.tap { |o| o.update(name: 'World') }) }
+      specify { expect(object).to eql(object.clone.tap { |o| o.update(name: 'World') }) }
+    end
+
+    context do
+      let(:object) { model.new(name: 'Hello') }
+      specify { expect(object).to eq(object) }
+      specify { expect(object).to eql(object) }
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe ActiveData::Model::Scopes do
+  let(:model) do
+    stub_model do
+      include ActiveData::Model::Scopes
+
+      attribute :name, String
+
+      class << self
+        def except_first
+          scope[1..-1]
+        end
+
+        def no_mars
+          scope.delete_if { |i| i.name == 'Mars' }
+        end
+
+      private
+
+        def hidden_method
+        end
+      end
+    end
+  end
+
+  let(:hash_scoped_model) do
+    stub_model do
+      include ActiveData::Model::Scopes
+      scopify Hash
+    end
+  end
+
+  describe '.scope_class' do
+    specify { expect(model.scope_class).to be < Array }
+    specify { expect(model.scope_class).to eq(model::ScopeProxy) }
+    specify { expect(model.scope_class._scope_model).to eq(model) }
+    specify { expect(model.scope_class.new).to be_empty }
+
+    specify { expect(hash_scoped_model.scope_class).to be < Hash }
+    specify { expect(hash_scoped_model.scope_class).to eq(hash_scoped_model::ScopeProxy) }
+    specify { expect(hash_scoped_model.scope_class._scope_model).to eq(hash_scoped_model) }
+    specify { expect(hash_scoped_model.scope_class.new).to be_empty }
+
+    context do
+      let(:scope) { model.scope([model.new(name: 'Hello'), model.new(name: 'World'), model.new(name: 'Mars')]) }
+
+      specify { expect(scope).to be_instance_of model.scope_class }
+      specify { expect { model.scope([model.new(name: 'Hello'), {}]) }.to raise_error ActiveData::AssociationTypeMismatch }
+
+      context 'scopes' do
+        specify { expect(scope.except_first).to be_instance_of model.scope_class }
+        specify { expect(scope.no_mars).to be_instance_of model.scope_class }
+        specify { expect(scope.except_first).to eq(model.scope([model.new(name: 'World'), model.new(name: 'Mars')])) }
+        specify { expect(scope.no_mars).to eq(model.scope([model.new(name: 'Hello'), model.new(name: 'World')])) }
+        specify { expect(scope.except_first.no_mars).to eq(model.scope([model.new(name: 'World')])) }
+        specify { expect(scope.no_mars.except_first).to eq(model.scope([model.new(name: 'World')])) }
+        specify { expect { scope.hidden_method }.to raise_error NoMethodError }
+
+        specify { expect(scope).to respond_to(:no_mars) }
+        specify { expect(scope).to respond_to(:except_first) }
+        specify { expect(scope).not_to respond_to(:hidden_method) }
+      end
+    end
+  end
+
+  context do
+    let!(:ancestor) do
+      stub_model do
+        include ActiveData::Model::Scopes
+      end
+    end
+
+    let!(:descendant1) do
+      Class.new ancestor
+    end
+
+    let!(:descendant2) do
+      Class.new ancestor
+    end
+
+    specify { expect(descendant1.scope_class).to be < Array }
+    specify { expect(descendant2.scope_class).to be < Array }
+    specify { expect(ancestor.scope_class).not_to eq(descendant1.scope_class) }
+    specify { expect(descendant1.scope_class).not_to eq(descendant2.scope_class) }
+  end
+end

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

@@ -0,0 +1,192 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe ActiveData::Model::Attributes do
+  subject { model.new }
+
+  context 'object' do
+    before { stub_class(:descendant) }
+    let(:model) { stub_model { attribute :column, Object } }
+
+    specify { expect(model.new(column: 'hello').column).to eq('hello') }
+    specify { expect(model.new(column: []).column).to eq([]) }
+    specify { expect(model.new(column: Descendant.new).column).to be_a(Descendant) }
+    specify { expect(model.new(column: Object.new).column).to be_a(Object) }
+    specify { expect(model.new(column: nil).column).to be_nil }
+
+    context do
+      before { stub_class(:descendant2, Descendant) }
+      let(:model) { stub_model { attribute :column, Descendant } }
+
+      specify { expect(model.new(column: 'hello').column).to be_nil }
+      specify { expect(model.new(column: []).column).to be_nil }
+      specify { expect(model.new(column: Descendant.new).column).to be_a(Descendant) }
+      specify { expect(model.new(column: Descendant2.new).column).to be_a(Descendant2) }
+      specify { expect(model.new(column: Object.new).column).to be_nil }
+      specify { expect(model.new(column: nil).column).to be_nil }
+    end
+  end
+
+  context 'string' do
+    let(:model) { stub_model { attribute :column, String } }
+
+    specify { expect(model.new(column: 'hello').column).to eq('hello') }
+    specify { expect(model.new(column: 123).column).to eq('123') }
+    specify { expect(model.new(column: nil).column).to be_nil }
+  end
+
+  context 'integer' do
+    let(:model) { stub_model { attribute :column, Integer } }
+
+    specify { expect(model.new(column: 'hello').column).to be_nil }
+    specify { expect(model.new(column: '123hello').column).to be_nil }
+    specify { expect(model.new(column: '123').column).to eq(123) }
+    specify { expect(model.new(column: '123.5').column).to eq(123) }
+    specify { expect(model.new(column: 123).column).to eq(123) }
+    specify { expect(model.new(column: 123.5).column).to eq(123) }
+    specify { expect(model.new(column: nil).column).to be_nil }
+    specify { expect(model.new(column: [123]).column).to be_nil }
+  end
+
+  context 'float' do
+    let(:model) { stub_model { attribute :column, Float } }
+
+    specify { expect(model.new(column: 'hello').column).to be_nil }
+    specify { expect(model.new(column: '123hello').column).to be_nil }
+    specify { expect(model.new(column: '123').column).to eq(123.0) }
+    specify { expect(model.new(column: '123.').column).to be_nil }
+    specify { expect(model.new(column: '123.5').column).to eq(123.5) }
+    specify { expect(model.new(column: 123).column).to eq(123.0) }
+    specify { expect(model.new(column: 123.5).column).to eq(123.5) }
+    specify { expect(model.new(column: nil).column).to be_nil }
+    specify { expect(model.new(column: [123.5]).column).to be_nil }
+  end
+
+  context 'big_decimal' do
+    let(:model) { stub_model { attribute :column, BigDecimal } }
+
+    specify { expect(model.new(column: 'hello').column).to be_nil }
+    specify { expect(model.new(column: '123hello').column).to be_nil }
+    specify { expect(model.new(column: '123').column).to eq(BigDecimal.new('123.0')) }
+    specify { expect(model.new(column: '123.').column).to be_nil }
+    specify { expect(model.new(column: '123.5').column).to eq(BigDecimal.new('123.5')) }
+    specify { expect(model.new(column: 123).column).to eq(BigDecimal.new('123.0')) }
+    specify { expect(model.new(column: 123.5).column).to eq(BigDecimal.new('123.5')) }
+    specify { expect(model.new(column: nil).column).to be_nil }
+    specify { expect(model.new(column: [123.5]).column).to be_nil }
+  end
+
+  context 'boolean' do
+    let(:model) { stub_model { attribute :column, Boolean } }
+
+    specify { expect(model.new(column: 'hello').column).to be_nil }
+    specify { expect(model.new(column: 'true').column).to eq(true) }
+    specify { expect(model.new(column: 'false').column).to eq(false) }
+    specify { expect(model.new(column: '1').column).to eq(true) }
+    specify { expect(model.new(column: '0').column).to eq(false) }
+    specify { expect(model.new(column: true).column).to eq(true) }
+    specify { expect(model.new(column: false).column).to eq(false) }
+    specify { expect(model.new(column: 1).column).to eq(true) }
+    specify { expect(model.new(column: 0).column).to eq(false) }
+    specify { expect(model.new(column: nil).column).to be_nil }
+    specify { expect(model.new(column: [123]).column).to be_nil }
+  end
+
+  context 'array' do
+    let(:model) { stub_model { attribute :column, Array } }
+
+    specify { expect(model.new(column: [1, 2, 3]).column).to eq([1, 2, 3]) }
+    specify { expect(model.new(column: 'hello, world').column).to eq(['hello', 'world']) }
+    specify { expect(model.new(column: 10).column).to be_nil }
+  end
+
+  context 'date' do
+    let(:model) { stub_model { attribute :column, Date } }
+    let(:date) { Date.new(2013, 6, 13) }
+
+    specify { expect(model.new(column: nil).column).to be_nil }
+    specify { expect(model.new(column: '2013-06-13').column).to eq(date) }
+    specify { expect(model.new(column: '2013-55-55').column).to be_nil }
+    specify { expect(model.new(column: 'blablabla').column).to be_nil }
+    specify { expect(model.new(column: DateTime.new(2013, 6, 13, 23, 13)).column).to eq(date) }
+    specify { expect(model.new(column: Time.new(2013, 6, 13, 23, 13)).column).to eq(date) }
+    specify { expect(model.new(column: Date.new(2013, 6, 13)).column).to eq(date) }
+  end
+
+  context 'datetime' do
+    let(:model) { stub_model { attribute :column, DateTime } }
+    let(:datetime) { DateTime.new(2013, 6, 13, 23, 13) }
+
+    specify { expect(model.new(column: nil).column).to be_nil }
+    specify { expect(model.new(column: '2013-06-13 23:13').column).to eq(datetime) }
+    specify { expect(model.new(column: '2013-55-55 55:55').column).to be_nil }
+    specify { expect(model.new(column: 'blablabla').column).to be_nil }
+    specify { expect(model.new(column: Date.new(2013, 6, 13)).column).to eq(DateTime.new(2013, 6, 13, 0, 0)) }
+    specify { expect(model.new(column: Time.utc(2013, 6, 13, 23, 13).utc).column).to eq(DateTime.new(2013, 6, 13, 23, 13)) }
+    specify { expect(model.new(column: DateTime.new(2013, 6, 13, 23, 13)).column).to eq(DateTime.new(2013, 6, 13, 23, 13)) }
+  end
+
+  context 'time' do
+    let(:model) { stub_model { attribute :column, Time } }
+
+    specify { expect(model.new(column: nil).column).to be_nil }
+    specify { expect(model.new(column: '2013-06-13 23:13').column).to eq('2013-06-13 23:13'.to_time) }
+    specify { expect(model.new(column: '2013-55-55 55:55').column).to be_nil }
+    specify { expect(model.new(column: 'blablabla').column).to be_nil }
+    specify { expect(model.new(column: Date.new(2013, 6, 13)).column).to eq(Time.new(2013, 6, 13, 0, 0)) }
+    specify { expect(model.new(column: DateTime.new(2013, 6, 13, 19, 13)).column).to eq(DateTime.new(2013, 6, 13, 19, 13).to_time) }
+    specify { expect(model.new(column: Time.new(2013, 6, 13, 23, 13)).column).to eq(Time.new(2013, 6, 13, 23, 13)) }
+
+    context 'Time.zone set' do
+      around { |example| Time.use_zone('Bangkok', &example) }
+
+      specify { expect(model.new(column: nil).column).to be_nil }
+      specify { expect(model.new(column: '2013-06-13 23:13').column).to eq(Time.zone.parse('2013-06-13 23:13')) }
+      specify { expect(model.new(column: '2013-55-55 55:55').column).to be_nil }
+      specify { expect(model.new(column: 'blablabla').column).to be_nil }
+      specify { expect(model.new(column: Date.new(2013, 6, 13)).column).to eq(Time.new(2013, 6, 13, 0, 0)) }
+      specify { expect(model.new(column: DateTime.new(2013, 6, 13, 19, 13)).column).to eq(DateTime.new(2013, 6, 13, 19, 13).to_time) }
+      specify { expect(model.new(column: Time.new(2013, 6, 13, 23, 13)).column).to eq(Time.new(2013, 6, 13, 23, 13)) }
+    end
+  end
+
+  context 'time_zone' do
+    let(:model) { stub_model { attribute :column, ActiveSupport::TimeZone } }
+
+    specify { expect(model.new(column: nil).column).to be_nil }
+    specify { expect(model.new(column: Object.new).column).to be_nil }
+    specify { expect(model.new(column: Time.now).column).to be_nil }
+    specify { expect(model.new(column: 'blablabla').column).to be_nil }
+    specify { expect(model.new(column: TZInfo::Timezone.all.first).column).to be_a ActiveSupport::TimeZone }
+    specify { expect(model.new(column: 'Moscow').column).to be_a ActiveSupport::TimeZone }
+    specify { expect(model.new(column: '+4').column).to be_a ActiveSupport::TimeZone }
+    specify { expect(model.new(column: '-3').column).to be_a ActiveSupport::TimeZone }
+    specify { expect(model.new(column: '3600').column).to be_a ActiveSupport::TimeZone }
+    specify { expect(model.new(column: '-7200').column).to be_a ActiveSupport::TimeZone }
+    specify { expect(model.new(column: 4).column).to be_a ActiveSupport::TimeZone }
+    specify { expect(model.new(column: -3).column).to be_a ActiveSupport::TimeZone }
+    specify { expect(model.new(column: 3600).column).to be_a ActiveSupport::TimeZone }
+    specify { expect(model.new(column: -7200).column).to be_a ActiveSupport::TimeZone }
+  end
+
+  context 'uuid' do
+    let(:model) { stub_model { attribute :column, ActiveData::UUID } }
+    let(:uuid) { ActiveData::UUID.random_create }
+    let(:uuid_tools) { UUIDTools::UUID.random_create }
+
+    specify { expect(uuid.as_json).to eq(uuid.to_s) }
+    specify { expect(uuid.to_json).to eq("\"#{uuid.to_s}\"") }
+    specify { expect(uuid.to_param).to eq(uuid.to_s) }
+    specify { expect(uuid.to_query(:key)).to eq("key=#{uuid.to_s}") }
+
+    specify { expect(model.new(column: nil).column).to be_nil }
+    specify { expect(model.new(column: Object.new).column).to be_nil }
+    specify { expect(model.new(column: uuid_tools).column).to be_a ActiveData::UUID  }
+    specify { expect(model.new(column: uuid_tools).column).to eq(uuid_tools) }
+    specify { expect(model.new(column: uuid).column).to eq(uuid) }
+    specify { expect(model.new(column: uuid.to_s).column).to eq(uuid) }
+    specify { expect(model.new(column: uuid.to_i).column).to eq(uuid) }
+    specify { expect(model.new(column: uuid.hexdigest).column).to eq(uuid) }
+    specify { expect(model.new(column: uuid.raw).column).to eq(uuid) }
+  end
+end

data/spec/lib/active_data/model/validations/associated_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe ActiveData::Model::Validations::AssociatedValidator do
+  before do
+    stub_model(:validated_assoc) do
+      include ActiveData::Model
+      include ActiveData::Model::Lifecycle
+
+      attribute :name, String
+
+      validates_presence_of :name
+    end
+
+    stub_model(:unvalidated_assoc) do
+      include ActiveData::Model
+      include ActiveData::Model::Lifecycle
+
+      attribute :name, String
+    end
+
+    stub_model(:main) do
+      include ActiveData::Model::Persistence
+      include ActiveData::Model::Associations
+
+      attribute :name, String
+
+      validates_presence_of :name
+      validates_associated :validated_one, :unvalidated_one, :validated_many, :unvalidated_many
+
+      embeds_one :validated_one, validate: false, class_name: 'ValidatedAssoc'
+      embeds_one :unvalidated_one, class_name: 'UnvalidatedAssoc'
+      embeds_many :validated_many, class_name: 'ValidatedAssoc'
+      embeds_many :unvalidated_many, class_name: 'UnvalidatedAssoc'
+    end
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', validated_one: { name: 'name' } }
+    it { is_expected.to be_valid }
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', validated_one: { } }
+    it { is_expected.not_to be_valid }
+    specify { expect { instance.validate }.to change { instance.errors.messages }
+      .to(validated_one: ['is invalid']) }
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', unvalidated_one: { name: 'name' } }
+    it { is_expected.to be_valid }
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', unvalidated_one: { } }
+    it { is_expected.to be_valid }
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{ name: 'name' }] }
+    it { is_expected.to be_valid }
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{ }] }
+    it { is_expected.not_to be_valid }
+    specify { expect { instance.validate }.to change { instance.errors.messages }
+      .to(:'validated_many.0.name' => ["can't be blank"], validated_many: ['is invalid']) }
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', unvalidated_many: [{ name: 'name' }] }
+    it { is_expected.to be_valid }
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', unvalidated_many: [{ }] }
+    it { is_expected.to be_valid }
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{ name: 'name' }], validated_one: { } }
+    it { is_expected.not_to be_valid }
+    specify { expect { instance.validate }.to change { instance.errors.messages }
+      .to(validated_one: ['is invalid']) }
+  end
+
+  context do
+    subject(:instance) { Main.instantiate name: 'hello', validated_many: [{ }], validated_one: { name: 'name' } }
+    it { is_expected.not_to be_valid }
+    specify { expect { instance.validate }.to change { instance.errors.messages }
+      .to(:'validated_many.0.name' => ["can't be blank"], validated_many: ['is invalid']) }
+  end
+end