active_data 0.3.0 → 1.0.0

data/spec/lib/active_data/model/associations/reflections/references_one_spec.rb

@@ -0,0 +1,208 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe ActiveData::Model::Associations::Reflections::ReferencesOne do
+  before do
+    stub_class(:author, ActiveRecord::Base) do
+      scope :name_starts_with_a, -> { where('name LIKE "a%"') }
+    end
+
+    stub_model(:book) do
+      include ActiveData::Model::Associations
+
+      attribute :title
+      references_one :author
+    end
+  end
+  let(:book) { Book.new }
+
+  specify { expect(book.author).to be_nil }
+
+  context ':class_name' do
+    before do
+      stub_model(:book) do
+        include ActiveData::Model::Associations
+
+        attribute :title
+        references_one :creator, class_name: 'Author'
+      end
+    end
+    let(:author) { Author.create!(name: 'Rick') }
+
+    specify { expect { book.creator = author }
+      .to change { book.creator }.from(nil).to(author) }
+    specify { expect { book.creator = author }
+      .to change { book.creator_id }.from(nil).to(author.id) }
+  end
+
+  describe ':primary_key' do
+    before do
+      stub_model(:book) do
+        include ActiveData::Model::Associations
+        attribute :author_name, String
+        references_one :author, primary_key: 'name'
+      end
+    end
+
+    let(:author) { Author.create!(name: 'Rick') }
+
+    specify { expect { book.author_name = author.name }
+      .to change { book.author }.from(nil).to(author) }
+    specify { expect { book.author = author }
+      .to change { book.author_name }.from(nil).to(author.name) }
+  end
+
+  describe ':reference_key' do
+    before do
+      stub_model(:book) do
+        include ActiveData::Model::Associations
+        references_one :author, reference_key: 'identify'
+      end
+    end
+
+    let(:author) { Author.create!(name: 'Rick') }
+
+    specify { expect { book.identify = author.id }
+      .to change { book.author }.from(nil).to(author) }
+    specify { expect { book.author = author }
+      .to change { book.identify }.from(nil).to(author.id) }
+  end
+
+  describe ':default' do
+    shared_examples_for :persisted_default do |default|
+      before do
+        stub_model(:book) do
+          include ActiveData::Model::Associations
+          references_one :author
+          references_one :owner, class_name: 'Author', default: default
+        end
+      end
+
+      let(:author) { Author.create! }
+      let(:other) { Author.create! }
+      let(:book) { Book.new(author: author) }
+
+      specify { expect(book.owner_id).to eq(author.id) }
+      specify { expect(book.owner).to eq(author) }
+      specify { expect { book.owner = other }.to change { book.owner_id }.from(author.id).to(other.id) }
+      specify { expect { book.owner = other }.to change { book.owner }.from(author).to(other) }
+      specify { expect { book.owner_id = other.id }.to change { book.owner_id }.from(author.id).to(other.id) }
+      specify { expect { book.owner_id = other.id }.to change { book.owner }.from(author).to(other) }
+      specify { expect { book.owner = nil }.to change { book.owner_id }.from(author.id).to(nil) }
+      specify { expect { book.owner = nil }.to change { book.owner }.from(author).to(nil) }
+      specify { expect { book.owner_id = nil }.not_to change { book.owner_id }.from(author.id) }
+      specify { expect { book.owner_id = nil }.not_to change { book.owner }.from(author) }
+      specify { expect { book.owner_id = '' }.to change { book.owner_id }.from(author.id).to(nil) }
+      specify { expect { book.owner_id = '' }.to change { book.owner }.from(author).to(nil) }
+    end
+
+    it_behaves_like :persisted_default, -> { author.id }
+    it_behaves_like :persisted_default, -> { author }
+
+    shared_examples_for :new_record_default do |default|
+      before do
+        stub_model(:book) do
+          include ActiveData::Model::Associations
+          references_one :author
+          references_one :owner, class_name: 'Author', default: default
+        end
+      end
+
+      let(:other) { Author.create! }
+      let(:book) { Book.new }
+
+      specify { expect(book.owner_id).to be_nil }
+      specify { expect(book.owner).to be_a(Author).and have_attributes(name: 'Author') }
+      specify { expect { book.owner = other }.to change { book.owner_id }.from(nil).to(other.id) }
+      specify { expect { book.owner = other }.to change { book.owner }.from(instance_of(Author)).to(other) }
+      specify { expect { book.owner_id = other.id }.to change { book.owner_id }.from(nil).to(other.id) }
+      specify { expect { book.owner_id = other.id }.to change { book.owner }.from(instance_of(Author)).to(other) }
+      specify { expect { book.owner = nil }.not_to change { book.owner_id }.from(nil) }
+      specify { expect { book.owner = nil }.to change { book.owner }.from(instance_of(Author)).to(nil) }
+      specify { expect { book.owner_id = nil }.not_to change { book.owner_id }.from(nil) }
+      specify { expect { book.owner_id = nil }.not_to change { book.owner }.from(instance_of(Author)) }
+      specify { expect { book.owner_id = '' }.not_to change { book.owner_id }.from(nil) }
+      specify { expect { book.owner_id = '' }.to change { book.owner }.from(instance_of(Author)).to(nil) }
+    end
+
+    it_behaves_like :new_record_default, name: 'Author'
+    it_behaves_like :new_record_default, -> { Author.new(name: 'Author') }
+  end
+
+  describe '#scope' do
+    before do
+      stub_model(:book) do
+        include ActiveData::Model::Associations
+        references_one :author, -> { name_starts_with_a }
+      end
+    end
+
+    let!(:author1) { Author.create!(name: 'Rick') }
+    let!(:author2) { Author.create!(name: 'Aaron') }
+
+    specify { expect { book.author_id = author1.id }
+      .not_to change { book.author } }
+    specify { expect { book.author_id = author2.id }
+      .to change { book.author }.from(nil).to(author2) }
+
+    specify { expect { book.author = author1 }
+      .to change { book.author_id }.from(nil).to(author1.id) }
+    specify { expect { book.author = author2 }
+      .to change { book.author_id }.from(nil).to(author2.id) }
+
+    specify { expect { book.author = author1 }
+      .to change { book.association(:author).reload; book.author_id }.from(nil).to(author1.id) }
+    specify { expect { book.author = author2 }
+      .to change { book.association(:author).reload; book.author_id }.from(nil).to(author2.id) }
+
+    specify { expect { book.author = author1 }
+      .not_to change { book.association(:author).reload; book.author } }
+    specify { expect { book.author = author2 }
+      .to change { book.association(:author).reload; book.author }.from(nil).to(author2) }
+  end
+
+  describe '#author=' do
+    let(:author) { Author.create! name: 'Author' }
+    specify { expect { book.author = author }.to change { book.author }.from(nil).to(author) }
+    specify { expect { book.author = 'string' }.to raise_error ActiveData::AssociationTypeMismatch }
+
+    context do
+      let(:other) { Author.create! name: 'Other' }
+      before { book.author = other }
+      specify { expect { book.author = author }.to change { book.author }.from(other).to(author) }
+      specify { expect { book.author = author }.to change { book.author_id }.from(other.id).to(author.id) }
+      specify { expect { book.author = nil }.to change { book.author }.from(other).to(nil) }
+      specify { expect { book.author = nil }.to change { book.author_id }.from(other.id).to(nil) }
+    end
+
+    context 'model not persisted' do
+      let(:author) { Author.new }
+      specify { expect { book.author = author }.to change { book.author }.from(nil).to(author) }
+      specify { expect { book.author = author }.not_to change { book.author_id }.from(nil) }
+
+      context do
+        before { book.author = author }
+        specify { expect { author.save! }.to change { book.author_id }.from(nil).to(an_instance_of(Fixnum)) }
+        specify { expect { author.save! }.not_to change { book.author } }
+      end
+    end
+  end
+
+  describe '#author_id=' do
+    let(:author) { Author.create!(name: 'Author') }
+    specify { expect { book.author_id = author.id }.to change { book.author_id }.from(nil).to(author.id) }
+    specify { expect { book.author_id = author.id }.to change { book.author }.from(nil).to(author) }
+
+    specify { expect { book.author_id = author.id.next.to_s }.to change { book.author_id }.from(nil).to(author.id.next) }
+    specify { expect { book.author_id = author.id.next.to_s }.not_to change { book.author }.from(nil) }
+
+    context do
+      let(:other) { Author.create!(name: 'Other') }
+      before { book.author = other }
+      specify { expect { book.author_id = author.id }.to change { book.author_id }.from(other.id).to(author.id) }
+      specify { expect { book.author_id = author.id }.to change { book.author }.from(other).to(author) }
+      specify { expect { book.author_id = nil }.to change { book.author_id }.from(other.id).to(nil) }
+      specify { expect { book.author_id = nil }.to change { book.author }.from(other).to(nil) }
+    end
+  end
+end

data/spec/lib/active_data/model/associations/validations_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe ActiveData::Model::Associations::Validations do
+  before do
+    stub_model(:project) do
+      include ActiveData::Model::Lifecycle
+      include ActiveData::Model::Associations
+
+      attribute :title, String
+      validates :title, presence: true
+
+      embeds_one :author do
+        attribute :name, String
+        validates :name, presence: true
+      end
+    end
+
+    stub_model(:profile) do
+      include ActiveData::Model::Lifecycle
+
+      attribute :first_name, String
+      attribute :last_name, String
+      validates :first_name, presence: true
+    end
+
+    stub_model(:user) do
+      include ActiveData::Model::Associations
+
+      attribute :login, String
+      validates :login, presence: true
+
+      embeds_one :profile, validate: false
+      embeds_many :projects
+    end
+  end
+
+  describe '#validate' do
+    let(:profile) { Profile.new first_name: 'Name' }
+    let(:project) { Project.new title: 'Project' }
+    let(:projects) { [project] }
+    let(:user) { User.new(login: 'Login', profile: profile, projects: projects) }
+    let(:author_attributes) { { name: 'Author' } }
+    before { project.build_author(author_attributes) }
+
+    specify { expect(user.validate).to eq(true) }
+    specify { expect { user.validate }.not_to change { user.errors.messages } }
+
+    context do
+      let(:author_attributes) { {} }
+
+      specify { expect(user.validate).to eq(false) }
+      specify { expect { user.validate }.to change { user.errors.messages }
+        .to(:'projects.0.author.name' => ["can't be blank"]) }
+    end
+
+    context do
+      let(:profile) { Profile.new }
+
+      specify { expect(user.validate).to eq(true) }
+      specify { expect { user.validate }.not_to change { user.errors.messages } }
+    end
+
+    context do
+      let(:projects) { [project, Project.new] }
+
+      specify { expect(user.validate).to eq(false) }
+      specify { expect { user.validate }.to change { user.errors.messages }
+        .to(:'projects.1.title' => ["can't be blank"]) }
+    end
+  end
+
+  describe '#validate_ancestry, #valid_ancestry?, #invalid_ancestry?' do
+    let(:profile) { Profile.new first_name: 'Name' }
+    let(:project) { Project.new title: 'Project' }
+    let(:projects) { [project] }
+    let(:user) { User.new(login: 'Login', profile: profile, projects: projects) }
+    let(:author_attributes) { { name: 'Author' } }
+    before { project.build_author(author_attributes) }
+
+    specify { expect(user.validate_ancestry).to eq(true) }
+    specify { expect(user.validate_ancestry!).to eq(true) }
+    specify { expect { user.validate_ancestry! }.not_to raise_error }
+    specify { expect(user.valid_ancestry?).to eq(true) }
+    specify { expect(user.invalid_ancestry?).to eq(false) }
+    specify { expect { user.validate_ancestry }.not_to change { user.errors.messages } }
+
+    context do
+      let(:author_attributes) { {} }
+      specify { expect(user.validate_ancestry).to eq(false) }
+      specify { expect { user.validate_ancestry! }.to raise_error ActiveData::ValidationError }
+      specify { expect(user.valid_ancestry?).to eq(false) }
+      specify { expect(user.invalid_ancestry?).to eq(true) }
+      specify { expect { user.validate_ancestry }.to change { user.errors.messages }
+        .to(:'projects.0.author.name' => ["can't be blank"]) }
+    end
+
+    context do
+      let(:profile) { Profile.new }
+      specify { expect(user.validate_ancestry).to eq(false) }
+      specify { expect { user.validate_ancestry! }.to raise_error ActiveData::ValidationError }
+      specify { expect(user.valid_ancestry?).to eq(false) }
+      specify { expect(user.invalid_ancestry?).to eq(true) }
+      specify { expect { user.validate_ancestry }.to change { user.errors.messages }
+        .to(:'profile.first_name' => ["can't be blank"]) }
+    end
+
+    context do
+      let(:projects) { [project, Project.new] }
+      specify { expect(user.validate_ancestry).to eq(false) }
+      specify { expect { user.validate_ancestry! }.to raise_error ActiveData::ValidationError }
+      specify { expect(user.valid_ancestry?).to eq(false) }
+      specify { expect(user.invalid_ancestry?).to eq(true) }
+      specify { expect { user.validate_ancestry }.to change { user.errors.messages }
+        .to(:'projects.1.title' => ["can't be blank"]) }
+
+      context do
+        before { user.update(login: '') }
+        specify { expect { user.validate_ancestry }.to change { user.errors.messages }
+          .to(:'projects.1.title' => ["can't be blank"], login: ["can't be blank"]) }
+      end
+    end
+  end
+
+  context 'represent attributes' do
+    before do
+      stub_class(:author, ActiveRecord::Base) do
+        validates :name, presence: true
+
+        # Emulate Active Record association auto save error.
+        def errors
+          super.tap do |errors|
+            errors.add(:'user.email', 'is invalid') if errors[:'user.email'].empty?
+          end
+        end
+      end
+
+      stub_model(:post) do
+        include ActiveData::Model::Associations
+
+        references_one :author
+        represents :name, of: :author
+        represents :email, of: :author
+      end
+    end
+
+    let(:post) { Post.new(author: Author.new) }
+
+    specify { expect { post.validate_ancestry }.to change { post.errors.messages }
+      .to(hash_including(:'author.user.email' => ['is invalid'], name: ["can't be blank"])) }
+    specify { expect { post.validate }.to change { post.errors.messages }
+      .to(hash_including(:'author.user.email' => ['is invalid'], name: ["can't be blank"])) }
+  end
+end

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

@@ -0,0 +1,189 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe ActiveData::Model::Associations do
+  context do
+    before do
+      stub_model(:nobody) do
+        include ActiveData::Model::Associations
+      end
+      stub_model(:project) do
+        include ActiveData::Model::Lifecycle
+      end
+      stub_model(:user, Nobody) do
+        include ActiveData::Model::Associations
+        embeds_many :projects
+      end
+      stub_model(:manager, Nobody) do
+        include ActiveData::Model::Associations
+        embeds_one :managed_project, class_name: 'Project'
+      end
+      stub_model(:admin, User) do
+        include ActiveData::Model::Associations
+        embeds_many :admin_projects, class_name: 'Project'
+
+        alias_association :own_projects, :admin_projects
+      end
+    end
+
+    describe '#reflections' do
+      specify { expect(Nobody.reflections.keys).to eq([]) }
+      specify { expect(User.reflections.keys).to eq([:projects]) }
+      specify { expect(Manager.reflections.keys).to eq([:managed_project]) }
+      specify { expect(Admin.reflections.keys).to eq([:projects, :admin_projects]) }
+    end
+
+    describe '#reflect_on_association' do
+      specify { expect(Nobody.reflect_on_association(:blabla)).to be_nil }
+      specify { expect(Admin.reflect_on_association('projects')).to be_a ActiveData::Model::Associations::Reflections::EmbedsMany }
+      specify { expect(Admin.reflect_on_association('own_projects').name).to eq(:admin_projects) }
+      specify { expect(Manager.reflect_on_association(:managed_project)).to be_a ActiveData::Model::Associations::Reflections::EmbedsOne }
+    end
+  end
+
+  context 'class determine errors' do
+    specify do
+      expect { stub_model do
+        include ActiveData::Model::Associations
+
+        embeds_one :author, class_name: 'Borogoves'
+      end.reflect_on_association(:author).klass }.to raise_error NameError
+    end
+
+    specify do
+      expect { stub_model(:user) do
+        include ActiveData::Model::Associations
+
+        embeds_many :projects, class_name: 'Borogoves' do
+          attribute :title
+        end
+      end.reflect_on_association(:projects).klass }.to raise_error NameError
+    end
+  end
+
+  context do
+    before do
+      stub_model(:project) do
+        include ActiveData::Model::Lifecycle
+        include ActiveData::Model::Associations
+
+        attribute :title, String
+
+        validates :title, presence: true
+
+        embeds_one :author do
+          attribute :name, String
+
+          validates :name, presence: true
+        end
+      end
+
+      stub_model(:profile) do
+        include ActiveData::Model::Lifecycle
+
+        attribute :first_name, String
+        attribute :last_name, String
+
+        validates :first_name, presence: true
+      end
+
+      stub_model(:user) do
+        include ActiveData::Model::Associations
+
+        attribute :login, Object
+
+        validates :login, presence: true
+
+        embeds_one :profile
+        embeds_many :projects
+
+        alias_association :my_profile, :profile
+      end
+    end
+
+    let(:user) { User.new }
+
+    its(:projects) { should = [] }
+    its(:profile) { should = nil }
+
+    describe '.inspect' do
+      specify { expect(User.inspect).to eq('User(profile: EmbedsOne(Profile), projects: EmbedsMany(Project), login: Object)') }
+    end
+
+    describe '.association_names' do
+      specify { expect(User.association_names).to eq([:profile, :projects]) }
+    end
+
+    describe '#inspect' do
+      let(:profile) { Profile.new first_name: 'Name' }
+      let(:project) { Project.new title: 'Project' }
+      specify { expect(User.new(login: 'Login', profile: profile, projects: [project]).inspect)
+        .to eq('#<User profile: #<EmbedsOne #<Profile first_name: "Name", last_name: nil>>, projects: #<EmbedsMany [#<Project author: #<EmbedsOne nil>, title: "P...]>, login: "Login">') }
+    end
+
+    describe '#==' do
+      let(:project) { Project.new title: 'Project' }
+      let(:other) { Project.new title: 'Other' }
+
+      specify { expect(User.new(projects: [project])).to eq(User.new(projects: [project])) }
+      specify { expect(User.new(projects: [project])).not_to eq(User.new(projects: [other])) }
+      specify { expect(User.new(projects: [project])).not_to eq(User.new) }
+
+      specify { expect(User.new(projects: [project])).to eql(User.new(projects: [project])) }
+      specify { expect(User.new(projects: [project])).not_to eql(User.new(projects: [other])) }
+      specify { expect(User.new(projects: [project])).not_to eql(User.new) }
+
+      context do
+        before { User.send(:include, ActiveData::Model::Primary) }
+        let(:user) { User.new(projects: [project]) }
+
+        specify { expect(user).to eq(user.clone.tap { |b| b.projects(author: project) }) }
+        specify { expect(user).to eq(user.clone.tap { |b| b.projects(author: other) }) }
+
+        specify { expect(user).to eql(user.clone.tap { |b| b.projects(author: project) }) }
+        specify { expect(user).to eql(user.clone.tap { |b| b.projects(author: other) }) }
+      end
+    end
+
+    describe '#association' do
+      specify { expect(user.association(:projects)).to be_a(ActiveData::Model::Associations::EmbedsMany) }
+      specify { expect(user.association(:profile)).to be_a(ActiveData::Model::Associations::EmbedsOne) }
+      specify { expect(user.association(:blabla)).to be_nil }
+      specify { expect(user.association('my_profile').reflection.name).to eq(:profile) }
+      specify { expect(user.association('my_profile')).to equal(user.association(:profile)) }
+    end
+
+    describe '#association_names' do
+      specify { expect(user.association_names).to eq([:profile, :projects]) }
+    end
+
+    describe '#apply_association_changes!' do
+      let(:profile) { Profile.new first_name: 'Name' }
+      let(:project) { Project.new title: 'Project' }
+      let(:user) { User.new(profile: profile, projects: [project]) }
+      before { project.build_author(name: 'Author') }
+
+      specify { expect { user.apply_association_changes! }.to change { user.attributes['profile'] }
+        .from(nil).to('first_name' => 'Name', 'last_name' => nil) }
+      specify { expect { user.apply_association_changes! }.to change { user.attributes['projects'] }
+        .from(nil).to([{ 'title' => 'Project', 'author' => { 'name' => 'Author' } }]) }
+
+      context do
+        let(:project) { Project.new }
+        specify { expect { user.apply_association_changes! }.to raise_error ActiveData::AssociationChangesNotApplied }
+      end
+    end
+
+    describe '#instantiate' do
+      before { User.send(:include, ActiveData::Model::Persistence) }
+      let(:profile) { Profile.new first_name: 'Name' }
+      let(:project) { Project.new title: 'Project' }
+      let(:user) { User.new(profile: profile, projects: [project]) }
+      before { project.build_author(name: 'Author') }
+
+      specify { expect(User.instantiate(JSON.parse(user.to_json))).to eq(user) }
+      specify { expect(User.instantiate(JSON.parse(user.to_json))
+        .tap { |u| u.projects.first.author.name = 'Other' }).not_to eq(user) }
+    end
+  end
+end