active_data 0.3.0 → 1.0.0

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

@@ -0,0 +1,134 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe ActiveData::Model::Associations::ReferencesOne do
+  before do
+    stub_class(:author, ActiveRecord::Base) { }
+
+    stub_model(:book) do
+      include ActiveData::Model::Persistence
+      include ActiveData::Model::Associations
+
+      attribute :title, String
+      references_one :author
+    end
+  end
+
+  let(:author) { Author.create!(name: 'Johny') }
+  let(:other) { Author.create!(name: 'Other') }
+  let(:book) { Book.new }
+  let(:association) { book.association(:author) }
+
+  let(:existing_book) { Book.instantiate title: 'My Life', author_id: author.id }
+  let(:existing_association) { existing_book.association(:author) }
+
+  describe 'book#association' do
+    specify { expect(association).to be_a described_class }
+    specify { expect(association).to eq(book.association(:author)) }
+  end
+
+  describe '#target' do
+    specify { expect(association.target).to be_nil }
+    specify { expect(existing_association.target).to eq(existing_book.author) }
+  end
+
+  describe '#loaded?' do
+    let(:new_author) { Author.create(name: 'Morty') }
+
+    specify { expect(association.loaded?).to eq(false) }
+    specify { expect { association.target }.to change { association.loaded? }.to(true) }
+    specify { expect { association.replace(new_author) }.to change { association.loaded? }.to(true) }
+    specify { expect { association.replace(nil) }.to change { association.loaded? }.to(true) }
+    specify { expect { existing_association.replace(new_author) }.to change { existing_association.loaded? }.to(true) }
+    specify { expect { existing_association.replace(nil) }.to change { existing_association.loaded? }.to(true) }
+  end
+
+  describe '#reload' do
+    specify { expect(association.reload).to be_nil }
+
+    specify { expect(existing_association.reload).to be_a Author }
+    specify { expect(existing_association.reload).to be_persisted }
+
+    context do
+      before { existing_association.reader.name = "New" }
+      specify { expect { existing_association.reload }
+        .to change { existing_association.reader.name }
+        .from('New').to('Johny') }
+    end
+  end
+
+  describe '#reader' do
+    specify { expect(association.reader).to be_nil }
+
+    specify { expect(existing_association.reader).to be_a Author }
+    specify { expect(existing_association.reader).to be_persisted }
+  end
+
+  describe '#default' do
+    before { Book.references_one :author, default: ->(book) { author.id } }
+    let(:existing_book) { Book.instantiate title: 'My Life' }
+
+    specify { expect(association.target).to eq(author) }
+    specify { expect { association.replace(other) }.to change { association.target }.to(other) }
+    specify { expect { association.replace(nil) }.to change { association.target }.to be_nil }
+
+    specify { expect(existing_association.target).to be_nil }
+    specify { expect { existing_association.replace(other) }.to change { existing_association.target }.to(other) }
+    specify { expect { existing_association.replace(nil) }.not_to change { existing_association.target } }
+  end
+
+
+  describe '#writer' do
+    context 'new owner' do
+      let(:new_author) { Author.new(name: 'Morty') }
+
+      let(:book) do
+        Book.new.tap do |book|
+          book.send(:mark_persisted!)
+        end
+      end
+
+      specify { expect { association.writer(nil) }
+        .not_to change { book.author_id } }
+      specify { expect { association.writer(new_author) }
+        .to change { association.reader.name rescue nil }.from(nil).to('Morty') }
+      specify { expect { association.writer(new_author) }
+        .not_to change { book.author_id }.from(nil) }
+
+    end
+
+    context 'persisted owner' do
+      let(:new_author) { Author.create(name: 'Morty') }
+
+      specify { expect { association.writer(stub_model(:dummy).new) }
+        .to raise_error ActiveData::AssociationTypeMismatch }
+
+      specify { expect(association.writer(nil)).to be_nil }
+      specify { expect(association.writer(new_author)).to eq(new_author) }
+      specify { expect { association.writer(nil) }
+        .not_to change { book.read_attribute(:author_id) } }
+      specify { expect { association.writer(new_author) }
+        .to change { association.reader.try(:attributes) }.from(nil).to('id' => 1, 'name' => 'Morty') }
+      specify { expect { association.writer(new_author) }
+        .to change { book.read_attribute(:author_id) } }
+
+
+      specify { expect { existing_association.writer(stub_class(:dummy, ActiveRecord::Base).new) rescue nil }
+        .not_to change { existing_book.read_attribute(:author_id) } }
+      specify { expect { existing_association.writer(stub_class(:dummy, ActiveRecord::Base).new) rescue nil }
+        .not_to change { existing_association.reader } }
+
+      specify { expect(existing_association.writer(nil)).to be_nil }
+      specify { expect(existing_association.writer(new_author)).to eq(new_author) }
+      specify { expect { existing_association.writer(nil) }
+        .to change { existing_book.read_attribute(:author_id) }.from(author.id).to(nil) }
+      specify { expect { existing_association.writer(new_author) }
+        .to change { existing_association.reader.try(:attributes) }
+        .from('id' => 1, 'name' => 'Johny').to('id' => 2, 'name' => 'Morty') }
+      specify { expect { existing_association.writer(new_author) }
+        .to change { existing_book.read_attribute(:author_id) }
+        .from(author.id).to(new_author.id) }
+
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe ActiveData::Model::Associations::Reflections::EmbedsMany do
+  before do
+    stub_model(:project) do
+      include ActiveData::Model::Lifecycle
+      attribute :title, String
+    end
+    stub_model(:user) do
+      include ActiveData::Model::Associations
+
+      attribute :name, String
+      embeds_many :projects
+    end
+  end
+  let(:user) { User.new }
+
+  context ':read, :write' do
+    before do
+      stub_model(:user) do
+        include ActiveData::Model::Persistence
+        include ActiveData::Model::Associations
+
+        attribute :name
+        embeds_many :projects,
+          read: ->(reflection, object) {
+            value = object.read_attribute(reflection.name)
+            JSON.parse(value) if value.present?
+          },
+          write: ->(reflection, object, value) {
+            object.write_attribute(reflection.name, value.to_json)
+          }
+      end
+    end
+
+    let(:user) { User.instantiate name: 'Rick', projects: [{title: 'Genesis'}].to_json }
+    let(:new_project1) { Project.new(title: 'Project 1') }
+    let(:new_project2) { Project.new(title: 'Project 2') }
+
+    specify { expect { user.projects.concat([new_project1, new_project2]) }
+      .to change { user.read_attribute(:projects) }
+      .from([{title: 'Genesis'}].to_json)
+      .to([{title: 'Genesis'}, {title: 'Project 1'}, {title: 'Project 2'}].to_json) }
+  end
+
+  describe '#projects' do
+    specify { expect(user.projects).to eq([]) }
+
+    describe '#build' do
+      let(:project) { Project.new title: 'Project' }
+      specify { expect(user.projects.build(title: 'Project')).to eq(project) }
+      specify { expect { user.projects.build(title: 'Project') }.to change { user.projects }.from([]).to([project]) }
+    end
+
+    describe '#create' do
+      let(:project) { Project.new title: 'Project' }
+      specify { expect(user.projects.create(title: 'Project')).to eq(project) }
+      specify { expect { user.projects.create(title: 'Project') }.to change { user.projects }.from([]).to([project]) }
+    end
+
+    describe '#create!' do
+      let(:project) { Project.new title: 'Project' }
+      specify { expect(user.projects.create!(title: 'Project')).to eq(project) }
+      specify { expect { user.projects.create!(title: 'Project') }.to change { user.projects }.from([]).to([project]) }
+    end
+
+    describe '#reload' do
+      let(:project) { Project.new title: 'Project' }
+      before do
+        user.update(projects: [project])
+        user.apply_association_changes!
+      end
+      before { user.projects.build }
+
+      specify { expect(user.projects.count).to eq(2) }
+      specify { expect(user.projects.reload).to eq([project]) }
+    end
+
+    describe '#concat' do
+      let(:project) { Project.new title: 'Project' }
+      specify { expect { user.projects.concat project }.to change { user.projects }.from([]).to([project]) }
+      specify { expect { user.projects.concat project, 'string' }.to raise_error ActiveData::AssociationTypeMismatch }
+
+      context do
+        let(:other) { Project.new title: 'Other' }
+        before { user.projects = [other] }
+        specify { expect { user.projects.concat project }.to change { user.projects }.from([other]).to([other, project]) }
+      end
+    end
+  end
+
+  describe '#projects=' do
+    let(:project) { Project.new title: 'Project' }
+    specify { expect { user.projects = [] }.not_to change { user.projects }.from([]) }
+    specify { expect { user.projects = [project] }.to change { user.projects }.from([]).to([project]) }
+    specify { expect { user.projects = [project, 'string'] }.to raise_error ActiveData::AssociationTypeMismatch }
+
+    context do
+      let(:other) { Project.new title: 'Other' }
+      before { user.projects = [other] }
+      specify { expect { user.projects = [project] }.to change { user.projects }.from([other]).to([project]) }
+      specify { expect { user.projects = [] }.to change { user.projects }.from([other]).to([]) }
+    end
+  end
+
+  context 'on the fly' do
+    context do
+      before do
+        stub_model(:user) do
+          include ActiveData::Model::Associations
+
+          attribute :title, String
+          embeds_many :projects do
+            attribute :title, String
+          end
+        end
+      end
+
+      specify { expect(User.reflect_on_association(:projects).klass).to eq(User::Project) }
+      specify { expect(User.new.projects).to eq([]) }
+      specify { expect(User.new.tap { |u| u.projects.create(title: 'Project') }.projects).to be_a(ActiveData::Model::Associations::Collection::Embedded) }
+      specify { expect(User.new.tap { |u| u.projects.create(title: 'Project') }.read_attribute(:projects)).to eq([{'title' => 'Project'}]) }
+    end
+
+    context do
+      before do
+        stub_model(:user) do
+          include ActiveData::Model::Associations
+
+          attribute :title, String
+          embeds_many :projects, class_name: 'Project' do
+            attribute :value, String
+          end
+        end
+      end
+
+      specify { expect(User.reflect_on_association(:projects).klass).to eq(User::Project) }
+      specify { expect(User.new.projects).to eq([]) }
+      specify { expect(User.new.tap { |u| u.projects.create(title: 'Project') }.projects).to be_a(ActiveData::Model::Associations::Collection::Embedded) }
+      specify { expect(User.new.tap { |u| u.projects.create(title: 'Project') }.read_attribute(:projects)).to eq([{'title' => 'Project', 'value' => nil}]) }
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe ActiveData::Model::Associations::Reflections::EmbedsOne do
+  before do
+    stub_model(:author) do
+      include ActiveData::Model::Lifecycle
+      attribute :name, String
+    end
+
+    stub_model(:book) do
+      include ActiveData::Model::Associations
+
+      attribute :title, String
+      embeds_one :author
+    end
+  end
+  let(:book) { Book.new }
+
+  specify { expect(book.author).to be_nil }
+
+  context ':read, :write' do
+    before do
+      stub_model(:book) do
+        include ActiveData::Model::Persistence
+        include ActiveData::Model::Associations
+
+        attribute :title
+        embeds_one :author,
+          read: ->(reflection, object) {
+            value = object.read_attribute(reflection.name)
+            JSON.parse(value) if value.present?
+          },
+          write: ->(reflection, object, value) {
+            object.write_attribute(reflection.name, value ? value.to_json : nil)
+          }
+      end
+    end
+
+    let(:book) { Book.instantiate author: {name: 'Duke'}.to_json }
+    let(:author) { Author.new(name: 'Rick') }
+
+    specify { expect { book.author = author }
+      .to change { book.read_attribute(:author) }
+      .from({name: 'Duke'}.to_json).to({name: 'Rick'}.to_json) }
+  end
+
+  describe '#author=' do
+    let(:author) { Author.new 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.new name: 'Other' }
+      before { book.author = other }
+      specify { expect { book.author = author }.to change { book.author }.from(other).to(author) }
+      specify { expect { book.author = nil }.to change { book.author }.from(other).to(nil) }
+    end
+  end
+
+  describe '#build_author' do
+    let(:author) { Author.new name: 'Author' }
+    specify { expect(book.build_author(name: 'Author')).to eq(author) }
+    specify { expect { book.build_author(name: 'Author') }.to change { book.author }.from(nil).to(author) }
+  end
+
+  describe '#create_author' do
+    let(:author) { Author.new name: 'Author' }
+    specify { expect(book.create_author(name: 'Author')).to eq(author) }
+    specify { expect { book.create_author(name: 'Author') }.to change { book.author }.from(nil).to(author) }
+  end
+
+  describe '#create_author!' do
+    let(:author) { Author.new name: 'Author' }
+    specify { expect(book.create_author!(name: 'Author')).to eq(author) }
+    specify { expect { book.create_author!(name: 'Author') }.to change { book.author }.from(nil).to(author) }
+  end
+
+  context 'on the fly' do
+    context do
+      before do
+        stub_model(:book) do
+          include ActiveData::Model::Associations
+
+          attribute :title, String
+          embeds_one :author do
+            attribute :name, String
+          end
+        end
+      end
+
+      specify { expect(Book.reflect_on_association(:author).klass).to eq(Book::Author) }
+      specify { expect(Book.new.author).to be_nil }
+      specify { expect(Book.new.tap { |b| b.create_author(name: 'Author') }.author).to be_a(Book::Author) }
+      specify { expect(Book.new.tap { |b| b.create_author(name: 'Author') }.read_attribute(:author)).to eq('name' => 'Author') }
+    end
+
+    context do
+      before do
+        stub_model(:book) do
+          include ActiveData::Model::Associations
+
+          attribute :title, String
+          embeds_one :author, class_name: 'Author' do
+            attribute :age, Integer
+          end
+        end
+      end
+
+      specify { expect(Book.reflect_on_association(:author).klass).to eq(Book::Author) }
+      specify { expect(Book.new.author).to be_nil }
+      specify { expect(Book.new.tap { |b| b.create_author(name: 'Author') }.author).to be_a(Book::Author) }
+      specify { expect(Book.new.tap { |b| b.create_author(name: 'Author') }.read_attribute(:author)).to eq('name' => 'Author', 'age' => nil) }
+    end
+  end
+end

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

@@ -0,0 +1,255 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe ActiveData::Model::Associations::Reflections::ReferencesMany 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_many :authors
+    end
+  end
+
+  let(:author) { Author.create!(name: 'Rick') }
+  let(:other) { Author.create!(name: 'John') }
+  let(:book) { Book.new }
+  let(:book_with_author) { Book.new(authors: [author]) }
+
+  specify { expect(book.authors).to be_empty }
+
+  context ':class_name' do
+    before do
+      stub_model(:book) do
+        include ActiveData::Model::Associations
+
+        attribute :title
+        references_many :creators, class_name: 'Author'
+      end
+    end
+
+    let(:book) { Book.new }
+
+    specify { expect { book.creators << author }
+      .to change { book.creators }.from([]).to([author]) }
+    specify { expect { book.creators << author }
+      .to change { book.creator_ids }.from([]).to([author.id]) }
+  end
+
+  describe ':primary_key' do
+    before do
+      stub_model(:book) do
+        include ActiveData::Model::Associations
+        collection :author_names, String
+        references_many :authors, primary_key: 'name'
+      end
+    end
+
+    let(:author) { Author.create!(name: 'Rick') }
+
+    specify { expect { book.author_names = [author.name] }
+      .to change { book.authors }.from([]).to([author]) }
+    specify { expect { book.authors = [author] }
+      .to change { book.author_names }.from([]).to([author.name]) }
+  end
+
+  describe ':reference_key' do
+    before do
+      stub_model(:book) do
+        include ActiveData::Model::Associations
+        references_many :authors, reference_key: 'identify'
+      end
+    end
+
+    let(:author) { Author.create!(name: 'Rick') }
+
+    specify { expect { book.identify = [author.id] }
+      .to change { book.authors }.from([]).to([author]) }
+    specify { expect { book.authors = [author] }
+      .to change { book.identify }.from([]).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_many :authors
+          references_many :owners, class_name: 'Author', default: default
+        end
+      end
+
+      let(:author) { Author.create! }
+      let(:other) { Author.create! }
+      let(:book) { Book.new(authors: [author]) }
+
+      specify { expect(book.owner_ids).to eq([author.id]) }
+      specify { expect(book.owners).to eq([author]) }
+      specify { expect { book.owners = [other] }.to change { book.owner_ids }.from([author.id]).to([other.id]) }
+      specify { expect { book.owners = [other] }.to change { book.owners }.from([author]).to([other]) }
+      specify { expect { book.owner_ids = [other.id] }.to change { book.owner_ids }.from([author.id]).to([other.id]) }
+      specify { expect { book.owner_ids = [other.id] }.to change { book.owners }.from([author]).to([other]) }
+      specify { expect { book.owners = [] }.to change { book.owner_ids }.from([author.id]).to([]) }
+      specify { expect { book.owners = [] }.to change { book.owners }.from([author]).to([]) }
+      specify { expect { book.owner_ids = [] }.not_to change { book.owner_ids }.from([author.id]) }
+      specify { expect { book.owner_ids = [] }.not_to change { book.owners }.from([author]) }
+      specify { expect { book.owner_ids = [nil] }.to change { book.owner_ids }.from([author.id]).to([]) }
+      specify { expect { book.owner_ids = [nil] }.to change { book.owners }.from([author]).to([]) }
+      specify { expect { book.owner_ids = [''] }.to change { book.owner_ids }.from([author.id]).to([]) }
+      specify { expect { book.owner_ids = [''] }.to change { book.owners }.from([author]).to([]) }
+      specify { expect { book.owner_ids = nil }.not_to change { book.owner_ids }.from([author.id]) }
+      specify { expect { book.owner_ids = nil }.not_to change { book.owners }.from([author]) }
+      specify { expect { book.owner_ids = '' }.to change { book.owner_ids }.from([author.id]).to([]) }
+      specify { expect { book.owner_ids = '' }.to change { book.owners }.from([author]).to([]) }
+    end
+
+    it_behaves_like :persisted_default, -> { authors.map(&:id) }
+    it_behaves_like :persisted_default, -> { authors }
+
+    shared_examples_for :new_record_default do |default|
+      before do
+        stub_model(:book) do
+          include ActiveData::Model::Associations
+          references_many :authors
+          references_many :owners, class_name: 'Author', default: default
+        end
+      end
+
+      let(:author) { Author.create! }
+      let(:book) { Book.new }
+
+      specify { expect(book.owner_ids).to eq([nil]) }
+      specify { expect(book.owners).to match([an_instance_of(Author).and(have_attributes(name: 'Author'))]) }
+      specify { expect { book.owners = [other] }.to change { book.owner_ids }.from([nil]).to([other.id]) }
+      specify { expect { book.owners = [other] }.to change { book.owners }.from([an_instance_of(Author)]).to([other]) }
+      specify { expect { book.owner_ids = [other.id] }.to change { book.owner_ids }.from([nil]).to([other.id]) }
+      specify { expect { book.owner_ids = [other.id] }.to change { book.owners }.from([an_instance_of(Author)]).to([other]) }
+      specify { expect { book.owners = [] }.to change { book.owner_ids }.from([nil]).to([]) }
+      specify { expect { book.owners = [] }.to change { book.owners }.from([an_instance_of(Author)]).to([]) }
+      specify { expect { book.owner_ids = [] }.not_to change { book.owner_ids }.from([nil]) }
+      specify { expect { book.owner_ids = [] }.not_to change { book.owners }.from([an_instance_of(Author)]) }
+      specify { expect { book.owner_ids = [nil] }.to change { book.owner_ids }.from([nil]).to([]) }
+      specify { expect { book.owner_ids = [nil] }.to change { book.owners }.from([an_instance_of(Author)]).to([]) }
+      specify { expect { book.owner_ids = [''] }.to change { book.owner_ids }.from([nil]).to([]) }
+      specify { expect { book.owner_ids = [''] }.to change { book.owners }.from([an_instance_of(Author)]).to([]) }
+      specify { expect { book.owner_ids = nil }.not_to change { book.owner_ids }.from([nil]) }
+      specify { expect { book.owner_ids = nil }.not_to change { book.owners }.from([an_instance_of(Author)]) }
+      specify { expect { book.owner_ids = '' }.to change { book.owner_ids }.from([nil]).to([]) }
+      specify { expect { book.owner_ids = '' }.to change { book.owners }.from([an_instance_of(Author)]).to([]) }
+    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_many :authors, -> { name_starts_with_a }
+      end
+    end
+
+    let!(:author1) { Author.create!(name: 'Rick') }
+    let!(:author2) { Author.create!(name: 'Aaron') }
+    specify { expect { book.authors = [author1, author2] }
+      .to change { book.authors }.from([]).to([author1, author2]) }
+    specify { expect { book.authors = [author1, author2] }
+      .to change { book.author_ids }.from([]).to([author1.id, author2.id]) }
+
+    specify { expect { book.author_ids = [author1.id, author2.id] }
+      .to change { book.authors }.from([]).to([author2]) }
+    specify { expect { book.author_ids = [author1.id, author2.id] }
+      .to change { book.author_ids }.from([]).to([author2.id]) }
+
+    specify { expect { book.authors = [author1, author2] }
+      .to change { book.authors.reload }.from([]).to([author2]) }
+    specify { expect { book.authors = [author1, author2] }
+      .to change { book.authors.reload; book.author_ids }.from([]).to([author2.id]) }
+  end
+
+  describe '#author' do
+    it { expect(book.authors).not_to respond_to(:build) }
+    it { expect(book.authors).not_to respond_to(:create) }
+    it { expect(book.authors).not_to respond_to(:create!) }
+
+    describe '#clear' do
+      it { expect { book_with_author.authors.clear }.to change { book_with_author.authors }.from([author]).to([]) }
+    end
+
+    describe '#reload' do
+      before { book.authors << author.tap { |a| a.name = 'Don Juan' } }
+      it { expect { book.authors.reload }.to change { book.authors.map(&:name) }.from(['Don Juan']).to(['Rick']) }
+    end
+
+    describe '#concat' do
+      it { expect { book.authors.concat author }.to change { book.authors }.from([]).to([author]) }
+      it { expect { book.authors << author << other }.to change { book.authors }.from([]).to([author, other]) }
+      context 'no duplication' do
+        before { book.authors << author }
+        it { expect { book.authors.concat author }.not_to change { book.authors }.from([author]) }
+      end
+    end
+
+    context 'scope missing method delegation' do
+      it { expect(book_with_author.authors.scope).to be_a ActiveRecord::Relation }
+      it { expect(book_with_author.authors.where(name: 'John')).to be_a ActiveRecord::Relation }
+      it { expect(book_with_author.authors.name_starts_with_a).to be_a ActiveRecord::Relation }
+    end
+  end
+
+  describe '#author_ids' do
+    it { expect(book_with_author.author_ids).to eq([author.id]) }
+    xit { expect { book_with_author.author_ids << other.id }.to change { book_with_author.authors }.from([author]).to([author, other]) }
+    it { expect { book_with_author.author_ids = [other.id] }.to change { book_with_author.authors }.from([author]).to([other]) }
+  end
+
+  describe '#authors=' do
+    specify { expect { book.authors = [author] }.to change { book.authors }.from([]).to([author]) }
+    specify { expect { book.authors = ['string'] }.to raise_error ActiveData::AssociationTypeMismatch }
+
+    context do
+      before { book.authors = [other] }
+      specify { expect { book.authors = [author] }.to change { book.authors }.from([other]).to([author]) }
+      specify { expect { book.authors = [author] }.to change { book.author_ids }.from([other.id]).to([author.id]) }
+      specify { expect { book.authors = [] }.to change { book.authors }.from([other]).to([]) }
+      specify { expect { book.authors = [] }.to change { book.author_ids }.from([other.id]).to([]) }
+    end
+
+    context 'model not persisted' do
+      let(:author) { Author.new }
+      specify { expect { book.authors = [author, other] }.to change { book.authors }.from([]).to([author, other]) }
+      specify { expect { book.authors = [author, other] }.to change { book.author_ids }.from([]).to([nil, other.id]) }
+
+      context do
+        before { book.authors = [author, other] }
+        specify { expect { author.save! }.to change { book.author_ids }.from([nil, other.id])
+          .to(match([an_instance_of(Fixnum), other.id])) }
+        specify { expect { author.save! }.not_to change { book.authors } }
+      end
+    end
+  end
+
+  describe '#author_ids=' do
+    specify { expect { book.author_ids = [author.id] }.to change { book.author_ids }.from([]).to([author.id]) }
+    specify { expect { book.author_ids = [author.id] }.to change { book.authors }.from([]).to([author]) }
+
+    specify { expect { book.author_ids = [author.id.next.to_s] }.not_to change { book.author_ids }.from([]) }
+    specify { expect { book.author_ids = [author.id.next.to_s] }.not_to change { book.authors }.from([]) }
+
+    specify { expect { book.author_ids = [author.id.next.to_s, author.id] }.to change { book.author_ids }.from([]).to([author.id]) }
+    specify { expect { book.author_ids = [author.id.next.to_s, author.id] }.to change { book.authors }.from([]).to([author]) }
+
+    context do
+      before { book.authors = [other] }
+      specify { expect { book.author_ids = [author.id] }.to change { book.author_ids }.from([other.id]).to([author.id]) }
+      specify { expect { book.author_ids = [author.id] }.to change { book.authors }.from([other]).to([author]) }
+      specify { expect { book.author_ids = [] }.to change { book.author_ids }.from([other.id]).to([]) }
+      specify { expect { book.author_ids = [] }.to change { book.authors }.from([other]).to([]) }
+    end
+  end
+end