require "spec_helper"

describe Mongoid::Relations::Referenced::ManyToMany do

  before(:all) do
    Mongoid.raise_not_found_error = true
    Person.autosaved_relations.delete_one(:preferences)
    Person.autosave(Person.relations["preferences"].merge!(autosave: true))
    Person.synced(Person.relations["preferences"])
  end

  after(:all) do
    Person.reset_callbacks(:save)
    Person.reset_callbacks(:destroy)
  end

  [ :<<, :push ].each do |method|

    describe "##{method}" do

      context "when the inverse_of is nil" do

        let!(:article) do
          Article.create
        end

        context "when the child document is new" do

          let(:preference) do
            Preference.new
          end

          before do
            article.preferences.send(method, preference)
          end

          it "persists the child document" do
            preference.should be_persisted
          end
        end

        context "when the child document is not new" do

          let(:preference) do
            Preference.create
          end

          it "does not persist the child document" do
            preference.should_receive(:save).never
            article.preferences.send(method, preference)
          end
        end
      end

      context "when the parent is a new record" do

        let(:person) do
          Person.new
        end

        let!(:preference) do
          Preference.new
        end

        let(:result) do
          person.preferences.send(method, preference)
        end

        it "returns an array of loaded documents" do
          result.should eq([ preference ])
        end
      end

      context "when the parent is not a new record" do

        let(:person) do
          Person.create
        end

        let!(:preference) do
          Preference.new
        end

        let(:result) do
          person.preferences.send(method, preference)
        end

        it "returns an array of loaded documents" do
          result.should eq([ preference ])
        end
      end

      context "when the relations are not polymorphic" do

        context "when the inverse relation is not defined" do

          let(:person) do
            Person.new
          end

          let(:house) do
            House.new
          end

          before do
            person.houses << house
          end

          it "appends the document to the relation" do
            person.houses.should eq([ house ])
          end

          it "sets the foreign key on the relation" do
            person.house_ids.should eq([ house.id ])
          end
        end

        context "when appending in a parent create block" do

          let!(:preference) do
            Preference.create(name: "testing")
          end

          let!(:person) do
            Person.create do |doc|
              doc.preferences << preference
            end
          end

          it "adds the documents to the relation" do
            person.preferences.should eq([ preference ])
          end

          it "sets the foreign key on the relation" do
            person.preference_ids.should eq([ preference.id ])
          end

          it "sets the foreign key on the inverse relation" do
            preference.person_ids.should eq([ person.id ])
          end

          it "saves the target" do
            preference.should be_persisted
          end

          it "adds the correct number of documents" do
            person.preferences.size.should eq(1)
          end

          it "persists the link" do
            person.reload.preferences.should eq([ preference ])
          end
        end

        context "when the parent is a new record" do

          let(:person) do
            Person.new
          end

          context "when the child is new" do

            let(:preference) do
              Preference.new
            end

            before do
              person.preferences.send(method, preference)
            end

            it "adds the documents to the relation" do
              person.preferences.should eq([ preference ])
            end

            it "sets the foreign key on the relation" do
              person.preference_ids.should eq([ preference.id ])
            end

            it "sets the foreign key on the inverse relation" do
              preference.person_ids.should eq([ person.id ])
            end

            it "does not save the target" do
              preference.should be_new_record
            end

            it "adds the correct number of documents" do
              person.preferences.size.should eq(1)
            end

            context "when appending a second time" do

              before do
                person.preferences.send(method, preference)
              end

              it "does not allow the document to be added again" do
                person.preferences.should eq([ preference ])
              end

              it "does not allow duplicate ids" do
                person.preference_ids.should eq([ preference.id ])
              end
            end
          end

          context "when the child is already persisted" do

            let!(:persisted) do
              Preference.create(name: "testy")
            end

            let(:preference) do
              Preference.first
            end

            before do
              person.preferences.send(method, preference)
              person.save
            end

            it "adds the documents to the relation" do
              person.preferences.should eq([ preference ])
            end

            it "sets the foreign key on the relation" do
              person.preference_ids.should eq([ preference.id ])
            end

            it "sets the foreign key on the inverse relation" do
              preference.person_ids.should eq([ person.id ])
            end

            it "saves the target" do
              preference.should be_persisted
            end

            it "adds the correct number of documents" do
              person.preferences.size.should eq(1)
            end

            it "persists the link" do
              person.reload.preferences.should eq([ preference ])
            end
          end

          context "when setting via the associated ids" do

            let!(:persisted) do
              Preference.create(name: "testy")
            end

            let(:preference) do
              Preference.first
            end

            let(:person) do
              Person.new(preference_ids: [ preference.id ])
            end

            before do
              person.save
            end

            it "adds the documents to the relation" do
              person.preferences.should eq([ preference ])
            end

            it "sets the foreign key on the relation" do
              person.preference_ids.should eq([ preference.id ])
            end

            it "sets the foreign key on the inverse relation" do
              preference.reload.person_ids.should eq([ person.id ])
            end

            it "adds the correct number of documents" do
              person.preferences.size.should eq(1)
            end

            it "persists the link" do
              person.reload.preferences.should eq([ preference ])
            end
          end
        end

        context "when the parent is not a new record" do

          let(:person) do
            Person.create
          end

          let(:preference) do
            Preference.new
          end

          before do
            person.preferences.send(method, preference)
          end

          it "adds the documents to the relation" do
            person.preferences.should eq([ preference ])
          end

          it "sets the foreign key on the relation" do
            person.preference_ids.should eq([ preference.id ])
          end

          it "sets the foreign key on the inverse relation" do
            preference.person_ids.should eq([ person.id ])
          end

          it "sets the base on the inverse relation" do
            preference.people.should eq([ person ])
          end

          it "sets the same instance on the inverse relation" do
            preference.people.first.should eql(person)
          end

          it "saves the target" do
            preference.should_not be_new_record
          end

          it "adds the document to the target" do
            person.preferences.count.should eq(1)
          end

          context "when documents already exist on the relation" do

            let(:preference_two) do
              Preference.new
            end

            before do
              person.preferences.send(method, preference_two)
            end

            it "adds the documents to the relation" do
              person.preferences.should eq([ preference, preference_two ])
            end

            it "sets the foreign key on the relation" do
              person.preference_ids.should eq([ preference.id, preference_two.id ])
            end

            it "sets the foreign key on the inverse relation" do
              preference_two.person_ids.should eq([ person.id ])
            end

            it "sets the base on the inverse relation" do
              preference_two.people.should eq([ person ])
            end

            it "sets the same instance on the inverse relation" do
              preference_two.people.first.should eql(person)
            end

            it "saves the target" do
              preference.should_not be_new_record
            end

            it "adds the document to the target" do
              person.preferences.count.should eq(2)
            end
          end
        end

        context "when both sides have been persisted" do

          let(:person) do
            Person.create
          end

          let(:event) do
            Event.create
          end

          before do
            person.administrated_events << event
          end

          it "sets the front side of the relation" do
            person.administrated_events.should eq([ event ])
          end

          it "sets the inverse side of the relation" do
            event.administrators(true).should eq([ person ])
          end

          context "when reloading" do

            it "sets the front side of the relation" do
              person.reload.administrated_events.should eq([ event ])
            end

            it "sets the inverse side of the relation" do
              event.reload.administrators.should eq([ person ])
            end
          end

          context "when performing a new database query" do

            let(:loaded_person) do
              Person.find(person.id)
            end

            let(:loaded_event) do
              Event.find(event.id)
            end

            it "sets the front side of the relation" do
              loaded_person.administrated_events.should eq([ event ])
            end

            it "sets the inverse side of the relation" do
              loaded_event.administrators.should eq([ person ])
            end
          end
        end

        context "when the relation also includes a has_many relation" do

          let(:artwork) do
            Artwork.create
          end

          let(:exhibition) do
            Exhibition.create
          end

          let(:exhibitor) do
            Exhibitor.create(exhibition: exhibition)
          end

          before do
            artwork.exhibitors << exhibitor
          end

          it "creates a single artwork object" do
            Artwork.count.should eq(1)
          end
        end

        context "when the relation is self referencing" do

          let(:tag_one) do
            Tag.create(text: "one")
          end

          let(:tag_two) do
            Tag.create(text: "two")
          end

          before do
            tag_one.related << tag_two
          end

          it "sets the front side of the relation" do
            tag_one.related.should eq([ tag_two ])
          end

          it "sets the inverse side of the relation" do
            tag_two.related(true).should eq([ tag_one ])
          end

          context "when reloading" do

            it "sets the front side of the relation" do
              tag_one.reload.related.should eq([ tag_two ])
            end

            it "sets the inverse side of the relation" do
              tag_two.reload.related.should eq([ tag_one ])
            end
          end

          context "when performing a new database query" do

            let(:loaded_tag_one) do
              Tag.find(tag_one.id)
            end

            let(:loaded_tag_two) do
              Tag.find(tag_two.id)
            end

            it "sets the front side of the relation" do
              loaded_tag_one.related.should eq([ tag_two ])
            end

            it "sets the inverse side of the relation" do
              loaded_tag_two.related.should eq([ tag_one ])
            end
          end
        end
      end

      context "when association has callbacks" do

        let(:post) do
          Post.new
        end

        let(:tag) do
          Tag.new
        end

        context "when the callback is a before_add" do

          it "executes the callback" do
            post.tags.send(method, tag)
            post.before_add_called.should be_true
          end

          context "when errors are raised" do

            before do
              post.should_receive(:before_add_tag).and_raise
            end

            it "does not add the document to the relation" do
              expect {
                post.tags.send(method, tag)
              }.to raise_error
              post.tags.should be_empty
            end
          end
        end

        context "when the callback is an after_add" do

          it "executes the callback" do
            post.tags.send(method, tag)
            post.after_add_called.should be_true
          end

          context "when errors are raised" do

            before do
              post.should_receive(:after_add_tag).and_raise
            end

            it "adds the document to the relation" do
              expect {
                post.tags.send(method, tag)
              }.to raise_error
              post.tags.should eq([ tag ])
            end
          end
        end
      end
    end
  end

  describe "#=" do

    context "when trying to add duplicate entries" do

      let(:person) do
        Person.new
      end

      let(:preference) do
        Preference.create(name: "one")
      end

      before do
        person.preferences = [ preference, preference ]
      end

      context "when the document is new" do

        it "does not add the duplicates" do
          person.preferences.should eq([ preference ])
        end

        it "does not create duplicate keys" do
          person.preference_ids.should eq([ preference.id ])
        end
      end

      context "when the document is persisted" do

        before do
          person.save
        end

        it "does not add the duplicates" do
          person.preferences.should eq([ preference ])
        end

        it "does not create duplicate keys" do
          person.preference_ids.should eq([ preference.id ])
        end

        it "does not add duplicates on the inverse" do
          preference.people.should eq([ person ])
        end

        it "does not add duplicate inverse keys" do
          preference.person_ids.should eq([ person.id ])
        end
      end
    end

    context "when the relation is not polymorphic" do

      context "when the parent and relation are new records" do

        let(:person) do
          Person.new
        end

        let(:preference) do
          Preference.new
        end

        before do
          person.preferences = [ preference ]
        end

        it "sets the relation" do
          person.preferences.should eq([ preference ])
        end

        it "sets the foreign key on the relation" do
          person.preference_ids.should eq([ preference.id ])
        end

        it "sets the foreign key on the inverse relation" do
          preference.person_ids.should eq([ person.id ])
        end

        it "does not save the target" do
          preference.should be_new_record
        end
      end

      context "when the parent is new but the relation exists" do

        let(:person) do
          Person.new
        end

        let!(:preference) do
          Preference.create
        end

        before do
          person.preferences = [ preference ]
        end

        it "sets the relation" do
          person.preferences.should eq([ preference ])
        end

        it "sets the foreign key on the relation" do
          person.preference_ids.should eq([ preference.id ])
        end

        it "sets the foreign key on the inverse relation" do
          preference.person_ids.should eq([ person.id ])
        end

        context "and the parent is persisted" do

          before do
            person.save!
            preference.reload
          end

          it "maintains the relation" do
            person.preferences.should eq([ preference ])
          end

          it "maintains the foreign key on the relation" do
            person.preference_ids.should eq([ preference.id ])
          end

          it "maintains the foreign key on the inverse relation" do
            preference.person_ids.should eq([ person.id ])
          end

          it "maintains the base on the inverse relation" do
            preference.people.first.should eq(person)
          end
        end
      end

      context "when the parent is not a new record" do

        let(:person) do
          Person.create
        end

        let(:preference) do
          Preference.new
        end

        before do
          person.preferences = [ preference ]
        end

        it "sets the relation" do
          person.preferences.should eq([ preference ])
        end

        it "sets the foreign key on the relation" do
          person.preference_ids.should eq([ preference.id ])
        end

        it "sets the foreign key on the inverse relation" do
          preference.person_ids.should eq([ person.id ])
        end

        it "sets the base on the inverse relation" do
          preference.people.first.should eq(person)
        end

        it "saves the target" do
          preference.should be_persisted
        end

        it "persists the relation" do
          person.reload.preferences == [ preference ]
        end

        context "when overwriting an existing relation" do

          let(:another_preference) do
            Preference.new
          end

          before do
            person.preferences = [ another_preference ]
          end

          it "sets the relation" do
            person.preferences.should eq([ another_preference ])
          end

          it "saves the target" do
            another_preference.should be_persisted
          end

          it "does not leave foreign keys of the previous relation" do
            person.preference_ids.should eq([ another_preference.id ])
          end

          it "clears its own key on the foreign relation" do
            preference.person_ids.should be_empty
          end

          context "and then overwriting it again with the same value" do

            before do
              person.preferences = [ another_preference ]
            end

            it "persists the relation between another_preference and person" do
              another_preference.reload.people.should eq([ person ])
            end

          end

          context "and person reloaded instead of saved" do

            before do
              person.reload
              another_preference.reload
            end

            it "persists the relation between person and another_preference" do
              person.preferences.should eq([ another_preference ])
            end

            it "persists the relation between another_prefrence and person" do
              another_preference.people.should eq([ person ])
            end

            it "no longer has any relation between preference and person" do
              preference.people.should be_empty
            end
          end

          context "and person is saved" do

            before do
              person.save
              person.reload
              another_preference.reload
            end

            it "persists the relation between person and another_preference" do
              person.preferences.should eq([ another_preference ])
            end

            it "persists the relation between another_prefrence and person" do
              another_preference.people.should eq([ person ])
            end

            it "no longer has any relation between preference and person" do
              preference.people.should be_empty
            end
          end
        end
      end
    end
  end

  [ nil, [] ].each do |value|

    describe "#= #{value}" do

      context "when the relation is not polymorphic" do

        context "when the inverse relation is not defined" do

          let(:person) do
            Person.new
          end

          let(:house) do
            House.new
          end

          before do
            person.houses << house
            person.houses = value
          end

          it "clears the relation" do
            person.houses.should be_empty
          end

          it "clears the foreign keys" do
            person.house_ids.should be_empty
          end
        end

        context "when the parent is a new record" do

          let(:person) do
            Person.new
          end

          let(:preference) do
            Preference.new
          end

          before do
            person.preferences = [ preference ]
            person.preferences = value
          end

          it "sets the relation to an empty array" do
            person.preferences.should be_empty
          end

          it "removed the inverse relation" do
            preference.people.should be_empty
          end

          it "removes the foreign key values" do
            person.preference_ids.should be_empty
          end

          it "removes the inverse foreign key values" do
            preference.person_ids.should be_empty
          end
        end

        context "when the parent is not a new record" do

          context "when the relation has been loaded" do

            let(:person) do
              Person.create
            end

            let(:preference) do
              Preference.new
            end

            before do
              person.preferences = [ preference ]
              person.preferences = value
            end

            it "sets the relation to an empty array" do
              person.preferences.should be_empty
            end

            it "removed the inverse relation" do
              preference.people.should be_empty
            end

            it "removes the foreign key values" do
              person.preference_ids.should be_empty
            end

            it "removes the inverse foreign key values" do
              preference.person_ids.should be_empty
            end

            it "does not delete the target from the database" do
              preference.should_not be_destroyed
            end
          end

          context "when the relation has not been loaded" do

            let(:preference) do
              Preference.new
            end

            let(:person) do
              Person.create.tap do |p|
                p.preferences = [ preference ]
              end
            end

            let!(:from_db) do
              Person.find(person.id)
            end

            before do
              from_db.preferences = value
            end

            it "sets the relation to an empty array" do
              from_db.preferences.should be_empty
            end

            it "removes the foreign key values" do
              from_db.preference_ids.should be_empty
            end
          end
        end
      end
    end
  end

  [ :build, :new ].each do |method|

    describe "##{method}" do

      context "when providing scoped mass assignment" do

        let(:person) do
          Person.new
        end

        let(:house) do
          person.houses.send(
            method,
            { name: "Dream", model: "Home" }, as: :admin
          )
        end

        it "sets the attributes for the provided role" do
          house.name.should eq("Dream")
        end

        it "does not set the attributes for other roles" do
          house.model.should be_nil
        end
      end

      context "when the relation is not polymorphic" do

        context "when the parent is a new record" do

          let(:person) do
            Person.new
          end

          let!(:preference) do
            person.preferences.send(method, name: "settings")
          end

          it "adds the document to the relation" do
            person.preferences.should eq([ preference ])
          end

          it "sets the foreign key on the relation" do
            person.preference_ids.should eq([ preference.id ])
          end

          it "sets the inverse foreign key on the relation" do
            preference.person_ids.should eq([ person.id ])
          end

          it "sets the attributes" do
            preference.name.should eq("settings")
          end

          it "does not save the target" do
            preference.should be_new_record
          end

          it "adds the correct number of documents" do
            person.preferences.size.should eq(1)
          end
        end

        context "when the parent is not a new record" do

          let(:person) do
            Person.create
          end

          let!(:preference) do
            person.preferences.send(method, name: "settings")
          end

          it "adds the document to the relation" do
            person.preferences.should eq([ preference ])
          end

          it "sets the foreign key on the relation" do
            person.preference_ids.should eq([ preference.id ])
          end

          it "sets the inverse foreign key on the relation" do
            preference.person_ids.should eq([ person.id ])
          end

          it "sets the base on the inverse relation" do
            preference.people.should eq([ person ])
          end

          it "sets the attributes" do
            preference.name.should eq("settings")
          end

          it "does not save the target" do
            preference.should be_new_record
          end

          it "adds the correct number of documents" do
            person.preferences.size.should eq(1)
          end

          context "when saving the target" do

            before do
              preference.save
            end

            it "persists the parent keys" do
              person.reload.preference_ids.should eq([ preference.id ])
            end
          end
        end
      end
    end
  end

  describe ".builder" do

    let(:builder_klass) do
      Mongoid::Relations::Builders::Referenced::ManyToMany
    end

    let(:document) do
      stub
    end

    let(:metadata) do
      stub(extension?: false)
    end

    it "returns the embedded in builder" do
      described_class.builder(nil, metadata, document).should
        be_a_kind_of(builder_klass)
    end
  end

  describe "#clear" do

    context "when the relation is not polymorphic" do

      context "when the parent has been persisted" do

        let!(:person) do
          Person.create
        end

        context "when the children are persisted" do

          let!(:preference) do
            person.preferences.create(name: "settings")
          end

          let!(:relation) do
            person.preferences.clear
          end

          it "clears out the relation" do
            person.preferences.should be_empty
          end

          it "removes the parent from the inverse relation" do
            preference.people.should_not include(person)
          end

          it "removes the foreign keys" do
            person.preference_ids.should be_empty
          end

          it "removes the parent key from the inverse" do
            preference.person_ids.should_not include(person.id)
          end

          it "does not delete the documents" do
            preference.should_not be_destroyed
          end

          it "persists the nullification" do
            person.reload.preferences.should be_empty
          end

          it "returns the relation" do
            relation.should be_empty
          end
        end

        context "when the children are not persisted" do

          let!(:preference) do
            person.preferences.build(name: "setting")
          end

          let!(:relation) do
            person.preferences.clear
          end

          it "clears out the relation" do
            person.preferences.should be_empty
          end
        end
      end

      context "when the parent is not persisted" do

        let(:person) do
          Person.new
        end

        let!(:preference) do
          person.preferences.build(name: "setting")
        end

        let!(:relation) do
          person.preferences.clear
        end

        it "clears out the relation" do
          person.preferences.should be_empty
        end
      end
    end

    context "when the association has callbacks" do

      let(:post) do
        Post.new
      end

      let(:tag) do
        Tag.new
      end

      before do
        post.tags << tag
      end

      context "when the callback is a before_remove" do

        context "when no errors are raised" do

          before do
            post.tags.clear
          end

          it "executes the callback" do
            post.before_remove_called.should be_true
          end

          it "removes the document from the relation" do
            post.tags.should be_empty
          end
        end

        context "when errors are raised" do

          before do
            post.should_receive(:before_remove_tag).and_raise
          end

          it "does not remove the document from the relation" do
            expect {
              post.tags.clear
            }.to raise_error
            post.tags.should eq([ tag ])
          end
        end
      end

      context "when the callback is an after_remove" do

        context "when no errors are raised" do

          before do
            post.tags.clear
          end

          it "executes the callback" do
            post.after_remove_called.should be_true
          end

          it "removes the document from the relation" do
            post.tags.should be_empty
          end
        end

        context "when errors are raised" do

          before do
            post.should_receive(:after_remove_tag).and_raise
          end

          it "removes the document from the relation" do
            expect {
              post.tags.clear
            }.to raise_error
            post.tags.should be_empty
          end
        end
      end
    end
  end

  describe "#concat" do

    context "when the parent is a new record" do

      let(:person) do
        Person.new
      end

      let!(:preference) do
        Preference.new
      end

      let(:result) do
        person.preferences.concat([ preference ])
      end

      it "returns an array of loaded documents" do
        result.should eq([ preference ])
      end
    end

    context "when the parent is not a new record" do

      let(:person) do
        Person.create
      end

      let!(:preference) do
        Preference.new
      end

      let(:result) do
        person.preferences.concat([ preference ])
      end

      it "returns an array of loaded documents" do
        result.should eq([ preference ])
      end
    end

    context "when the relations are not polymorphic" do

      context "when the inverse relation is not defined" do

        let(:person) do
          Person.new
        end

        let(:house) do
          House.new
        end

        before do
          person.houses.concat([ house ])
        end

        it "appends the document to the relation" do
          person.houses.should eq([ house ])
        end

        it "sets the foreign key on the relation" do
          person.house_ids.should eq([ house.id ])
        end
      end

      context "when appending in a parent create block" do

        let!(:preference) do
          Preference.create(name: "testing")
        end

        let!(:person) do
          Person.create do |doc|
            doc.preferences.concat([ preference ])
          end
        end

        it "adds the documents to the relation" do
          person.preferences.should eq([ preference ])
        end

        it "sets the foreign key on the relation" do
          person.preference_ids.should eq([ preference.id ])
        end

        it "sets the foreign key on the inverse relation" do
          preference.person_ids.should eq([ person.id ])
        end

        it "saves the target" do
          preference.should be_persisted
        end

        it "adds the correct number of documents" do
          person.preferences.size.should eq(1)
        end

        it "persists the link" do
          person.reload.preferences.should eq([ preference ])
        end
      end

      context "when the parent is a new record" do

        let(:person) do
          Person.new
        end

        context "when the child is new" do

          let(:preference) do
            Preference.new
          end

          before do
            person.preferences.concat([ preference ])
          end

          it "adds the documents to the relation" do
            person.preferences.should eq([ preference ])
          end

          it "sets the foreign key on the relation" do
            person.preference_ids.should eq([ preference.id ])
          end

          it "sets the foreign key on the inverse relation" do
            preference.person_ids.should eq([ person.id ])
          end

          it "does not save the target" do
            preference.should be_new_record
          end

          it "adds the correct number of documents" do
            person.preferences.size.should eq(1)
          end

          context "when appending a second time" do

            before do
              person.preferences.concat([ preference ])
            end

            it "does not allow the document to be added again" do
              person.preferences.should eq([ preference ])
            end

            it "does not allow duplicate ids" do
              person.preference_ids.should eq([ preference.id ])
            end
          end
        end

        context "when the child is already persisted" do

          let!(:persisted) do
            Preference.create(name: "testy")
          end

          let(:preference) do
            Preference.first
          end

          before do
            person.preferences.concat([ preference ])
            person.save
          end

          it "adds the documents to the relation" do
            person.preferences.should eq([ preference ])
          end

          it "sets the foreign key on the relation" do
            person.preference_ids.should eq([ preference.id ])
          end

          it "sets the foreign key on the inverse relation" do
            preference.person_ids.should eq([ person.id ])
          end

          it "saves the target" do
            preference.should be_persisted
          end

          it "adds the correct number of documents" do
            person.preferences.size.should eq(1)
          end

          it "persists the link" do
            person.reload.preferences.should eq([ preference ])
          end
        end

        context "when setting via the associated ids" do

          let!(:persisted) do
            Preference.create(name: "testy")
          end

          let(:preference) do
            Preference.first
          end

          let(:person) do
            Person.new(preference_ids: [ preference.id ])
          end

          before do
            person.save
          end

          it "adds the documents to the relation" do
            person.preferences.should eq([ preference ])
          end

          it "sets the foreign key on the relation" do
            person.preference_ids.should eq([ preference.id ])
          end

          it "sets the foreign key on the inverse relation" do
            preference.reload.person_ids.should eq([ person.id ])
          end

          it "adds the correct number of documents" do
            person.preferences.size.should eq(1)
          end

          it "persists the link" do
            person.reload.preferences.should eq([ preference ])
          end
        end
      end

      context "when the parent is not a new record" do

        let(:person) do
          Person.create
        end

        let(:preference) do
          Preference.new
        end

        before do
          person.preferences.concat([ preference ])
        end

        it "adds the documents to the relation" do
          person.preferences.should eq([ preference ])
        end

        it "sets the foreign key on the relation" do
          person.preference_ids.should eq([ preference.id ])
        end

        it "sets the foreign key on the inverse relation" do
          preference.person_ids.should eq([ person.id ])
        end

        it "sets the base on the inverse relation" do
          preference.people.should eq([ person ])
        end

        it "sets the same instance on the inverse relation" do
          preference.people.first.should eql(person)
        end

        it "saves the target" do
          preference.should_not be_new_record
        end

        it "adds the document to the target" do
          person.preferences.count.should eq(1)
        end

        context "when documents already exist on the relation" do

          let(:preference_two) do
            Preference.new
          end

          before do
            person.preferences.concat([ preference_two ])
          end

          it "adds the documents to the relation" do
            person.preferences.should eq([ preference, preference_two ])
          end

          it "sets the foreign key on the relation" do
            person.preference_ids.should eq([ preference.id, preference_two.id ])
          end

          it "sets the foreign key on the inverse relation" do
            preference_two.person_ids.should eq([ person.id ])
          end

          it "sets the base on the inverse relation" do
            preference_two.people.should eq([ person ])
          end

          it "sets the same instance on the inverse relation" do
            preference_two.people.first.should eql(person)
          end

          it "saves the target" do
            preference.should_not be_new_record
          end

          it "adds the document to the target" do
            person.preferences.count.should eq(2)
          end
        end
      end

      context "when both sides have been persisted" do

        let(:person) do
          Person.create
        end

        let(:event) do
          Event.create
        end

        before do
          person.administrated_events.concat([ event ])
        end

        it "sets the front side of the relation" do
          person.administrated_events.should eq([ event ])
        end

        it "sets the inverse side of the relation" do
          event.administrators(true).should eq([ person ])
        end

        context "when reloading" do

          it "sets the front side of the relation" do
            person.reload.administrated_events.should eq([ event ])
          end

          it "sets the inverse side of the relation" do
            event.reload.administrators.should eq([ person ])
          end
        end

        context "when performing a new database query" do

          let(:loaded_person) do
            Person.find(person.id)
          end

          let(:loaded_event) do
            Event.find(event.id)
          end

          it "sets the front side of the relation" do
            loaded_person.administrated_events.should eq([ event ])
          end

          it "sets the inverse side of the relation" do
            loaded_event.administrators.should eq([ person ])
          end
        end
      end

      context "when the relation also includes a has_many relation" do

        let(:artwork) do
          Artwork.create
        end

        let(:exhibition) do
          Exhibition.create
        end

        let(:exhibitor) do
          Exhibitor.create(exhibition: exhibition)
        end

        before do
          artwork.exhibitors.concat([ exhibitor ])
        end

        it "creates a single artwork object" do
          Artwork.count.should eq(1)
        end
      end

      context "when the relation is self referencing" do

        let(:tag_one) do
          Tag.create(text: "one")
        end

        let(:tag_two) do
          Tag.create(text: "two")
        end

        before do
          tag_one.related.concat([ tag_two ])
        end

        it "sets the front side of the relation" do
          tag_one.related.should eq([ tag_two ])
        end

        it "sets the inverse side of the relation" do
          tag_two.related(true).should eq([ tag_one ])
        end

        context "when reloading" do

          it "sets the front side of the relation" do
            tag_one.reload.related.should eq([ tag_two ])
          end

          it "sets the inverse side of the relation" do
            tag_two.reload.related.should eq([ tag_one ])
          end
        end

        context "when performing a new database query" do

          let(:loaded_tag_one) do
            Tag.find(tag_one.id)
          end

          let(:loaded_tag_two) do
            Tag.find(tag_two.id)
          end

          it "sets the front side of the relation" do
            loaded_tag_one.related.should eq([ tag_two ])
          end

          it "sets the inverse side of the relation" do
            loaded_tag_two.related.should eq([ tag_one ])
          end
        end
      end
    end
  end

  describe "#count" do

    let(:person) do
      Person.create
    end

    context "when nothing exists on the relation" do

      context "when the document is destroyed" do

        before do
          Meat.create!
        end

        let!(:sandwich) do
          Sandwich.create!
        end

        it "returns zero" do
          sandwich.destroy
          sandwich.meats.count.should eq(0)
        end
      end
    end

    context "when documents have been persisted" do

      let!(:preference) do
        person.preferences.create(name: "setting")
      end

      it "returns the number of persisted documents" do
        person.preferences.count.should eq(1)
      end
    end

    context "when appending to a loaded relation" do

      let!(:preference) do
        person.preferences.create(name: "setting")
      end

      before do
        person.preferences.count
        person.preferences << Preference.create(name: "two")
      end

      it "returns the number of persisted documents" do
        person.preferences.count.should eq(2)
      end
    end

    context "when documents have not been persisted" do

      let!(:preference) do
        person.preferences.build(name: "settings")
      end

      it "returns 0" do
        person.preferences.count.should eq(0)
      end
    end

    context "when new documents exist in the database" do

      context "when the documents are part of the relation" do

        before do
          Preference.create(person_ids: [ person.id ])
        end

        it "returns the count from the db" do
          person.reload.preferences.count.should eq(1)
        end
      end

      context "when the documents are not part of the relation" do

        before do
          Preference.create
        end

        it "returns the count from the db" do
          person.preferences.count.should eq(0)
        end
      end
    end

    context "when the inverse relation is not defined" do

      context "when documents have been persisted" do

        let!(:house) do
          person.houses.create(name: "Wayne Manor")
        end

        it "returns the number of persisted documents" do
          person.houses.count.should eq(1)
        end
      end

      context "when documents have not been persisted" do

        let!(:house) do
          person.houses.build(name: "Ryugyong Hotel")
        end

        it "returns 0" do
          person.preferences.count.should eq(0)
        end
      end
    end
  end

  [ :create, :create! ].each do |method|

    describe "##{method}" do

      context "when providing scoped mass assignment" do

        let(:person) do
          Person.create
        end

        let(:house) do
          person.houses.send(
            method,
            { name: "Dream", model: "Home" }, as: :admin
          )
        end

        it "sets the attributes for the provided role" do
          house.name.should eq("Dream")
        end

        it "does not set the attributes for other roles" do
          house.model.should be_nil
        end
      end

      context "when the relation is not polymorphic" do

        context "when using string keys" do

          let(:agent) do
            Agent.create(number: "007")
          end

          before do
            agent.accounts.create(name: "testing again")
          end

          it "does not convert the string key to an object id" do
            agent.account_ids.should eq([ "testing-again" ])
          end
        end

        context "when the parent is a new record" do

          let(:person) do
            Person.new
          end

          it "raises an unsaved document error" do
            expect {
              person.preferences.send(method, name: "Testing")
            }.to raise_error(Mongoid::Errors::UnsavedDocument)
          end
        end

        context "when the parent is not a new record" do

          let(:person) do
            Person.send(method)
          end

          let!(:preference) do
            person.preferences.send(method, name: "Testing")
          end

          it "sets the foreign key on the relation" do
            person.preference_ids.should eq([ preference.id ])
          end

          it "sets the foreign key on the inverse relation" do
            preference.person_ids.should eq([ person.id ])
          end

          it "adds the document" do
            person.preferences.should eq([ preference ])
          end

          it "sets the base on the inverse relation" do
            preference.people.should eq([ person ])
          end

          it "sets the attributes" do
            preference.name.should eq("Testing")
          end

          it "saves the target" do
            preference.should be_persisted
          end

          it "adds the document to the target" do
            person.preferences.count.should eq(1)
          end

          it "does not duplicate documents" do
            person.reload.preferences.count.should eq(1)
          end

          it "does not duplicate ids" do
            person.reload.preference_ids.count.should eq(1)
          end
        end
      end
    end
  end

  describe "#create!" do

    context "when validation fails" do

      let(:person) do
        Person.create
      end

      context "when the relation is not polymorphic" do

        it "raises an error" do
          expect {
            person.preferences.create!(name: "a")
          }.to raise_error(Mongoid::Errors::Validations)
        end
      end
    end
  end

  describe "#delete" do

    let(:person) do
      Person.create
    end

    let(:preference_one) do
      Preference.create(name: "Testing")
    end

    let(:preference_two) do
      Preference.create(name: "Test")
    end

    before do
      person.preferences << [ preference_one, preference_two ]
    end

    context "when the document exists" do

      let!(:deleted) do
        person.preferences.delete(preference_one)
      end

      it "removes the document from the relation" do
        person.preferences.should eq([ preference_two ])
      end

      it "returns the document" do
        deleted.should eq(preference_one)
      end

      it "removes the document key from the foreign key" do
        person.preference_ids.should eq([ preference_two.id ])
      end

      it "removes the inverse reference" do
        deleted.reload.people.should be_empty
      end

      it "removes the base id from the inverse keys" do
        deleted.reload.person_ids.should be_empty
      end

      context "and person and preferences are reloaded" do

        before do
          person.reload
          preference_one.reload
          preference_two.reload
        end

        it "nullifies the deleted preference" do
          person.preferences.should eq([ preference_two ])
        end

        it "retains the ids for one preference" do
          person.preference_ids.should eq([ preference_two.id ])
        end
      end
    end

    context "when the document does not exist" do

      let!(:deleted) do
        person.preferences.delete(Preference.new)
      end

      it "returns nil" do
        deleted.should be_nil
      end

      it "does not modify the relation" do
        person.preferences.should eq([ preference_one, preference_two ])
      end

      it "does not modify the keys" do
        person.preference_ids.should eq([ preference_one.id, preference_two.id ])
      end
    end

    context "when :dependent => :nullify is set" do

      context "when :inverse_of is set" do

        let(:event) do
          Event.create
        end

        before do
          person.administrated_events << [ event ]
        end

        it "deletes the document" do
          event.delete.should be_true
        end
      end
    end

    context "when the relationships are self referencing" do

      let(:tag_one) do
        Tag.create(text: "one")
      end

      let(:tag_two) do
        Tag.create(text: "two")
      end

      before do
        tag_one.related << tag_two
      end

      context "when deleting without reloading" do

        let!(:deleted) do
          tag_one.related.delete(tag_two)
        end

        it "deletes the document from the relation" do
          tag_one.related.should be_empty
        end

        it "deletes the foreign key from the relation" do
          tag_one.related_ids.should be_empty
        end

        it "removes the reference from the inverse" do
          deleted.related.should be_empty
        end

        it "removes the foreign keys from the inverse" do
          deleted.related_ids.should be_empty
        end
      end

      context "when deleting with reloading" do

        context "when deleting from the front side" do

          let(:reloaded) do
            tag_one.reload
          end

          let!(:deleted) do
            reloaded.related.delete(tag_two)
          end

          it "deletes the document from the relation" do
            reloaded.related.should be_empty
          end

          it "deletes the foreign key from the relation" do
            reloaded.related_ids.should be_empty
          end

          it "removes the reference from the inverse" do
            deleted.related.should be_empty
          end

          it "removes the foreign keys from the inverse" do
            deleted.related_ids.should be_empty
          end
        end

        context "when deleting from the inverse side" do

          let(:reloaded) do
            tag_two.reload
          end

          let!(:deleted) do
            reloaded.related.delete(tag_one)
          end

          it "deletes the document from the relation" do
            reloaded.related.should be_empty
          end

          it "deletes the foreign key from the relation" do
            reloaded.related_ids.should be_empty
          end

          it "removes the foreign keys from the inverse" do
            deleted.related_ids.should be_empty
          end
        end
      end
    end

    context "when the association has callbacks" do

      let(:post) do
        Post.new
      end

      let(:tag) do
        Tag.new
      end

      before do
        post.tags << tag
      end

      context "when the callback is a before_remove" do

        context "when there are no errors" do

          before do
            post.tags.delete tag
          end

          it "executes the callback" do
            post.before_remove_called.should be_true
          end

          it "removes the document from the relation" do
            post.tags.should be_empty
          end
        end

        context "when errors are raised" do

          before do
            post.should_receive(:before_remove_tag).and_raise
          end

          it "does not remove the document from the relation" do
            expect {
              post.tags.delete tag
            }.to raise_error
            post.tags.should eq([ tag ])
          end
        end
      end

      context "when the callback is an after_remove" do

        context "when no errors are raised" do

          before do
            post.tags.delete(tag)
          end

          it "executes the callback" do
            post.after_remove_called.should be_true
          end

          it "removes the document from the relation" do
            post.tags.should be_empty
          end
        end

        context "when errors are raised" do

          before do
            post.should_receive(:after_remove_tag).and_raise
          end

          it "removes the document from the relation" do
            expect {
              post.tags.delete(tag)
            }.to raise_error
            post.tags.should be_empty
          end
        end
      end
    end
  end

  [ :delete_all, :destroy_all ].each do |method|

    describe "##{method}" do

      context "when the relation is not polymorphic" do

        context "when conditions are provided" do

          let(:person) do
            Person.create
          end

          let!(:preference_one) do
            person.preferences.create(name: "Testing")
          end

          let!(:preference_two) do
            person.preferences.create(name: "Test")
          end

          let!(:deleted) do
            person.preferences.send(
              method,
              { name: "Testing" }
            )
          end

          it "removes the correct preferences" do
            person.preferences.count.should eq(1)
          end

          it "deletes the documents from the database" do
            Preference.where(name: "Testing").count.should eq(0)
          end

          it "returns the number of documents deleted" do
            deleted.should eq(1)
          end

          it "removes the ids from the foreign key" do
            person.preference_ids.should eq([ preference_two.id ])
          end
        end

        context "when conditions are not provided" do

          let(:person) do
            Person.create.tap do |person|
              person.preferences.create(name: "Testing")
              person.preferences.create(name: "Test")
            end
          end

          let!(:deleted) do
            person.preferences.send(method)
          end

          it "removes the correct preferences" do
            person.preferences.count.should eq(0)
          end

          it "deletes the documents from the database" do
            Preference.count.should eq(0)
          end

          it "returns the number of documents deleted" do
            deleted.should eq(2)
          end
        end
      end
    end
  end

  describe ".eager_load" do

    before do
      Mongoid.identity_map_enabled = true
    end

    after do
      Mongoid.identity_map_enabled = false
    end

    context "when the relation is not polymorphic" do

      let!(:person) do
        Person.create
      end

      let!(:preference) do
        person.preferences.create(name: "testing")
      end

      let(:metadata) do
        Person.relations["preferences"]
      end

      let(:ids) do
        [ preference.id ]
      end

      let!(:eager) do
        described_class.eager_load(metadata, ids)
      end

      let(:map) do
        Mongoid::IdentityMap.get(Preference, ids)
      end

      it "puts the documents in the identity map" do
        map.should eq([ preference ])
      end
    end
  end

  describe ".embedded?" do

    it "returns false" do
      described_class.should_not be_embedded
    end
  end

  describe "#exists?" do

    let!(:person) do
      Person.create
    end

    context "when documents exist in the database" do

      before do
        person.preferences.create
      end

      it "returns true" do
        person.preferences.exists?.should be_true
      end
    end

    context "when no documents exist in the database" do

      before do
        person.preferences.build
      end

      it "returns false" do
        person.preferences.exists?.should be_false
      end
    end
  end

  describe "#find" do

    context "when the relation is not polymorphic" do

      let(:person) do
        Person.create
      end

      let!(:preference_one) do
        person.preferences.create(name: "Test")
      end

      let!(:preference_two) do
        person.preferences.create(name: "OMG I has relations")
      end

      let!(:unrelated_pref) do
        Preference.create(name: "orphan annie")
      end

      let!(:unrelated_pref_two) do
        Preference.create(name: "orphan two")
      end

      context "when providing an id" do

        context "when the id matches" do

          let(:preference) do
            person.preferences.find(preference_one.id)
          end

          it "returns the matching document" do
            preference.should eq(preference_one)
          end
        end

        context "when the id matches an unreferenced document" do

          let(:preference) do
            person.preferences.find(unrelated_pref.id)
          end

          it "raises an error" do
            expect {
              preference
            }.to raise_error(Mongoid::Errors::DocumentNotFound)
          end
        end

        context "when the id does not match" do

          context "when config set to raise error" do

            before do
              Mongoid.raise_not_found_error = true
            end

            it "raises an error" do
              expect {
                person.preferences.find(Moped::BSON::ObjectId.new)
              }.to raise_error(Mongoid::Errors::DocumentNotFound)
            end
          end

          context "when config set not to raise error" do

            let(:preference) do
              person.preferences.find(Moped::BSON::ObjectId.new)
            end

            before do
              Mongoid.raise_not_found_error = false
            end

            after do
              Mongoid.raise_not_found_error = true
            end

            it "returns nil" do
              preference.should be_nil
            end
          end
        end
      end

      context "when providing an array of ids" do

        context "when the ids match" do

          let(:preferences) do
            person.preferences.find([ preference_one.id, preference_two.id ])
          end

          it "returns the matching documents" do
            preferences.should eq([ preference_one, preference_two ])
          end
        end

        context "when the ids matche unreferenced documents" do

          let(:preferences) do
            person.preferences.find(
              [ unrelated_pref.id, unrelated_pref_two.id ]
            )
          end

          it "raises an error" do
            expect {
              preferences
            }.to raise_error(Mongoid::Errors::DocumentNotFound)
          end
        end

        context "when the ids do not match" do

          context "when config set to raise error" do

            before do
              Mongoid.raise_not_found_error = true
            end

            it "raises an error" do
              expect {
                person.preferences.find([ Moped::BSON::ObjectId.new ])
              }.to raise_error(Mongoid::Errors::DocumentNotFound)
            end
          end

          context "when config set not to raise error" do

            let(:preferences) do
              person.preferences.find([ Moped::BSON::ObjectId.new ])
            end

            before do
              Mongoid.raise_not_found_error = false
            end

            after do
              Mongoid.raise_not_found_error = true
            end

            it "returns an empty array" do
              preferences.should be_empty
            end
          end
        end
      end
    end
  end

  describe "#find_or_create_by" do

    context "when the relation is not polymorphic" do

      let(:person) do
        Person.create
      end

      let!(:preference) do
        person.preferences.create(name: "Testing")
      end

      context "when the document exists" do

        let(:found) do
          person.preferences.find_or_create_by(name: "Testing")
        end

        it "returns the document" do
          found.should eq(preference)
        end
      end

      context "when the document does not exist" do

        let(:found) do
          person.preferences.find_or_create_by(name: "Test")
        end

        it "sets the new document attributes" do
          found.name.should eq("Test")
        end

        it "returns a newly persisted document" do
          found.should be_persisted
        end
      end
    end
  end

  describe "#find_or_initialize_by" do

    context "when the relation is not polymorphic" do

      let(:person) do
        Person.create
      end

      let!(:preference) do
        person.preferences.create(name: "Testing")
      end

      context "when the document exists" do

        let(:found) do
          person.preferences.find_or_initialize_by(name: "Testing")
        end

        it "returns the document" do
          found.should eq(preference)
        end
      end

      context "when the document does not exist" do

        let(:found) do
          person.preferences.find_or_initialize_by(name: "Test")
        end

        it "sets the new document attributes" do
          found.name.should eq("Test")
        end

        it "returns a non persisted document" do
          found.should_not be_persisted
        end
      end
    end
  end

  describe ".foreign_key_suffix" do

    it "returns _ids" do
      described_class.foreign_key_suffix.should eq("_ids")
    end
  end

  describe ".macro" do

    it "returns has_and_belongs_to_many" do
      described_class.macro.should eq(:has_and_belongs_to_many)
    end
  end

  describe "#max" do

    let(:person) do
      Person.create
    end

    let(:preference_one) do
      Preference.create(ranking: 5)
    end

    let(:preference_two) do
      Preference.create(ranking: 10)
    end

    before do
      person.preferences.push(preference_one, preference_two)
    end

    let(:max) do
      person.preferences.max do |a,b|
        a.ranking <=> b.ranking
      end
    end

    it "returns the document with the max value of the supplied field" do
      max.should eq(preference_two)
    end
  end

  describe "#max_by" do

    let(:person) do
      Person.create
    end

    let(:preference_one) do
      Preference.create(ranking: 5)
    end

    let(:preference_two) do
      Preference.create(ranking: 10)
    end

    before do
      person.preferences.push(preference_one, preference_two)
    end

    let(:max) do
      person.preferences.max_by(&:ranking)
    end

    it "returns the document with the max value of the supplied field" do
      max.should eq(preference_two)
    end
  end

  describe "#method_missing" do

    let!(:person) do
      Person.create
    end

    let!(:preference_one) do
      person.preferences.create(name: "First", value: "Posting")
    end

    let!(:preference_two) do
      person.preferences.create(name: "Second", value: "Testing")
    end

    let!(:unrelated) do
      Preference.create(name: "Third")
    end

    context "when providing a single criteria" do

      let(:preferences) do
        person.preferences.where(name: "First")
      end

      it "applies the criteria to the documents" do
        preferences.should eq([ preference_one ])
      end
    end

    context "when providing a criteria on id" do

      let(:preferences) do
        person.preferences.where(_id: unrelated.id)
      end

      it "does not return unrelated documents" do
        preferences.should be_empty
      end
    end

    context "when providing a criteria class method" do

      let(:preferences) do
        person.preferences.posting
      end

      it "applies the criteria to the documents" do
        preferences.should eq([ preference_one ])
      end
    end

    context "when chaining criteria" do

      let(:preferences) do
        person.preferences.posting.where(:name.in => [ "First" ])
      end

      it "applies the criteria to the documents" do
        preferences.should eq([ preference_one ])
      end
    end

    context "when delegating methods" do

      describe "#distinct" do

        it "returns the distinct values for the fields" do
          person.preferences.distinct(:name).should =~
            [ "First",  "Second"]
        end

        context "when the inverse relation is not defined" do

          let!(:house) do
            person.houses.create(name: "Wayne Manor")
          end

          it "returns the distinct values for the fields" do
            person.houses.distinct(:name).should eq([ house.name ])
          end
        end
      end
    end
  end

  describe "#min" do

    let(:person) do
      Person.create
    end

    let(:preference_one) do
      Preference.create(ranking: 5)
    end

    let(:preference_two) do
      Preference.create(ranking: 10)
    end

    before do
      person.preferences.push(preference_one, preference_two)
    end

    let(:min) do
      person.preferences.min do |a, b|
        a.ranking <=> b.ranking
      end
    end

    it "returns the min value of the supplied field" do
      min.should eq(preference_one)
    end
  end

  describe "#min_by" do

    let(:person) do
      Person.create
    end

    let(:preference_one) do
      Preference.create(ranking: 5)
    end

    let(:preference_two) do
      Preference.create(ranking: 10)
    end

    before do
      person.preferences.push(preference_one, preference_two)
    end

    let(:min) do
      person.preferences.min_by(&:ranking)
    end

    it "returns the min value of the supplied field" do
      min.should eq(preference_one)
    end
  end

  describe "#nil?" do

    it "returns false" do
      Person.new.preferences.should_not be_nil
    end
  end

  describe "#nullify_all" do

    let(:person) do
      Person.create
    end

    let!(:preference_one) do
      person.preferences.create(name: "One")
    end

    let!(:preference_two) do
      person.preferences.create(name: "Two")
    end

    before do
      person.preferences.nullify_all
    end

    it "removes the foreign key from the base document" do
      [ preference_one, preference_two ].each do |preference|
        person.preference_ids.should_not include(preference.id)
      end
    end

    it "removes the foreign key from the target documents" do
      [ preference_one, preference_two ].each do |preference|
        preference.person_ids.should_not include(person.id)
      end
    end

    it "removes the reference from the base document" do
      [ preference_one, preference_two ].each do |preference|
        person.preferences.should_not include(preference)
      end
    end

    it "removes the reference from the target documents" do
      [ preference_one, preference_two ].each do |preference|
        preference.people.should_not include(person)
      end
    end

    it "saves the documents" do
      preference_one.reload.people.should_not include(person)
    end
  end

  describe "#respond_to?" do

    let(:person) do
      Person.new
    end

    let(:preferences) do
      person.preferences
    end

    Array.public_instance_methods.each do |method|

      context "when checking #{method}" do

        it "returns true" do
          preferences.respond_to?(method).should be_true
        end
      end
    end

    Mongoid::Relations::Referenced::Many.public_instance_methods.each do |method|

      context "when checking #{method}" do

        it "returns true" do
          preferences.respond_to?(method).should be_true
        end
      end
    end

    Preference.scopes.keys.each do |method|

      context "when checking #{method}" do

        it "returns true" do
          preferences.respond_to?(method).should be_true
        end
      end
    end
  end

  describe ".stores_foreign_key?" do

    it "returns true" do
      described_class.stores_foreign_key?.should be_true
    end
  end

  describe "#scoped" do

    let(:person) do
      Person.new
    end

    let(:scoped) do
      person.preferences.scoped
    end

    it "returns the relation criteria" do
      scoped.should be_a(Mongoid::Criteria)
    end

    it "returns with an empty selector" do
      scoped.selector.should eq({ "$and" => [{ "_id" => { "$in" => [] }}]})
    end
  end

  [ :size, :length ].each do |method|

    describe "##{method}" do

      let(:person) do
        Person.create
      end

      context "when documents have been persisted" do

        let!(:preference) do
          person.preferences.create(name: "Testing")
        end

        it "returns the number of documents" do
          person.preferences.send(method).should eq(1)
        end
      end

      context "when documents have not been persisted" do

        before do
          person.preferences.build(name: "Test")
          person.preferences.create(name: "Test 2")
        end

        it "returns the total number of documents" do
          person.preferences.send(method).should eq(2)
        end
      end
    end
  end

  describe "#unscoped" do

    context "when the relation has no default scope" do

      let!(:person) do
        Person.create
      end

      let!(:preference_one) do
        person.preferences.create(name: "first")
      end

      let!(:preference_two) do
        Preference.create(name: "second")
      end

      let(:unscoped) do
        person.preferences.unscoped
      end

      it "returns only the associated documents" do
        unscoped.should eq([ preference_one ])
      end
    end

    context "when the relation has a default scope" do

      let!(:person) do
        Person.create
      end

      let!(:house_one) do
        person.houses.create(name: "first")
      end

      let!(:house_two) do
        House.create(name: "second")
      end

      let(:unscoped) do
        person.houses.unscoped
      end

      it "only returns associated documents" do
        unscoped.should eq([ house_one ])
      end

      it "removes the default scoping options" do
        unscoped.options.should eq({})
      end
    end
  end

  describe ".valid_options" do

    it "returns the valid options" do
      described_class.valid_options.should eq(
        [
          :after_add,
          :after_remove,
          :autosave,
          :before_add,
          :before_remove,
          :dependent,
          :foreign_key,
          :index,
          :order,
          :primary_key
        ]
      )
    end
  end

  describe ".validation_default" do

    it "returns true" do
      described_class.validation_default.should be_true
    end
  end

  context "when setting the ids directly after the documents" do

    let!(:person) do
      Person.create!(title: "The Boss")
    end

    let!(:girlfriend_house) do
      House.create!(name: "Girlfriend")
    end

    let!(:wife_house) do
      House.create!(name: "Wife")
    end

    let!(:exwife_house) do
      House.create!(name: "Ex-Wife")
    end

    before do
      person.update_attributes(
        houses: [ wife_house, exwife_house, girlfriend_house ]
      )
      person.update_attributes(house_ids: [ girlfriend_house.id ])
    end

    context "when reloading" do

      it "properly sets the references" do
        person.houses(true).should eq([ girlfriend_house ])
      end
    end
  end

  context "when setting both sides in a single call" do

    context "when the documents are new" do

      let(:user) do
        User.new(name: "testing")
      end

      let(:business) do
        Business.new(name: "serious", owners: [ user ])
      end

      before do
        user.businesses = [ business ]
      end

      it "sets the businesses" do
        user.businesses.should eq([ business ])
      end

      it "sets the inverse users" do
        user.businesses.first.owners.first.should eq(user)
      end

      it "sets the inverse businesses" do
        business.owners.should eq([ user ])
      end
    end

    context "when one side is persisted" do

      let!(:user) do
        User.new(name: "testing")
      end

      let!(:business) do
        Business.create(name: "serious", owners: [ user ])
      end

      before do
        user.businesses = [ business ]
      end

      it "sets the businesses" do
        user.businesses.should eq([ business ])
      end

      it "sets the inverse users" do
        user.businesses.first.owners.first.should eq(user)
      end

      it "sets the inverse businesses" do
        business.owners.should eq([ user ])
      end

      context "when reloading" do

        before do
          user.reload
          business.reload
        end

        it "persists the businesses" do
          user.businesses.should eq([ business ])
        end

        it "persists the inverse users" do
          user.businesses.first.owners.first.should eq(user)
        end

        it "persists the inverse businesses" do
          business.owners.should eq([ user ])
        end
      end
    end

    context "when the documents are persisted" do

      let(:user) do
        User.create(name: "tst")
      end

      let(:business) do
        Business.create(name: "srs", owners: [ user ])
      end

      before do
        user.businesses = [ business ]
      end

      it "sets the businesses" do
        user.businesses.should eq([ business ])
      end

      it "sets the inverse users" do
        user.businesses.first.owners.first.should eq(user)
      end

      it "sets the inverse businesses" do
        business.owners.should eq([ user ])
      end

      context "when reloading" do

        before do
          user.reload
          business.reload
        end

        it "persists the businesses" do
          user.businesses.should eq([ business ])
        end

        it "persists the inverse users" do
          user.businesses.first.owners.first.should eq(user)
        end

        it "persists the inverse businesses" do
          business.owners.should eq([ user ])
        end
      end
    end
  end

  context "when binding the relation multiple times" do

    let(:person) do
      Person.create
    end

    let(:preference) do
      person.preferences.create(name: "testing")
    end

    before do
      2.times do
        person.preferences.each do |preference|
          preference.person_ids.should eq([ person.id ])
        end
      end
    end

    it "does not duplicate foreign keys" do
      person.preference_ids.should eq([ preference.id ])
    end
  end

  context "when the association has order criteria" do

    let(:person) do
      Person.create
    end

    let(:preference_one) do
      OrderedPreference.create(name: 'preference-1', value: 10)
    end

    let(:preference_two) do
      OrderedPreference.create(name: 'preference-2', value: 20)
    end

    let(:preference_three) do
      OrderedPreference.create(name: 'preference-3', value: 20)
    end

    before do
      person.ordered_preferences.nullify_all
      person.ordered_preferences.push(preference_one, preference_two, preference_three)
    end

    it "orders the documents" do
      person.ordered_preferences(true).should eq(
        [preference_two, preference_three, preference_one]
      )
    end

    it "chains default criteria with additional" do
      person.ordered_preferences.order_by(:name.desc).to_a.should eq(
        [preference_three, preference_two, preference_one]
      )
    end
  end

  context "when the parent is not a new record and freshly loaded" do

    let(:person) do
      Person.create
    end

    let(:preference) do
      Preference.new
    end

    before do
      person.preferences = [ preference ]
      person.save
      person.reload
      person.preferences = nil
    end

    it "sets the relation to an empty array" do
      person.preferences.should be_empty
    end

    it "removes the foreign key values" do
      person.preference_ids.should be_empty
    end

    it "does not delete the target from the database" do
      expect {
        preference.reload
      }.not_to raise_error(Mongoid::Errors::DocumentNotFound)
    end
  end

  context "when reloading the relation" do

    let!(:person) do
      Person.create
    end

    let!(:preference_one) do
      Preference.create(name: "one")
    end

    let!(:preference_two) do
      Preference.create(name: "two")
    end

    before do
      person.preferences << preference_one
    end

    context "when the relation references the same documents" do

      before do
        Preference.collection.find({ _id: preference_one.id }).
          update({ "$set" => { name: "reloaded" }})
      end

      let(:reloaded) do
        person.preferences(true)
      end

      it "reloads the document from the database" do
        reloaded.first.name.should eq("reloaded")
      end
    end

    context "when the relation references different documents" do

      before do
        person.preferences << preference_two
      end

      let(:reloaded) do
        person.preferences(true)
      end

      it "reloads the new document from the database" do
        reloaded.should eq([ preference_one, preference_two ])
      end
    end
  end

  context "when adding to a relation via a field setter" do

    context "when the document is new" do

      let!(:person) do
        Person.create(preference_names: "one, two")
      end

      let(:preference_one) do
        person.reload.preferences.first
      end

      let(:preference_two) do
        person.reload.preferences.last
      end

      it "persists the first preference" do
        preference_one.should_not be_nil
      end

      it "sets the first inverse" do
        preference_one.people.should eq([ person ])
      end

      it "persists the second preference" do
        preference_two.should_not be_nil
      end

      it "sets the second inverse keys" do
        preference_two.people.should eq([ person ])
      end
    end
  end

  context "when changing the order of existing ids" do

    let(:person) do
      Person.new
    end

    let(:preference_one) do
      Preference.create(name: "one")
    end

    let(:preference_two) do
      Preference.create(name: "two")
    end

    before do
      person.preference_ids = [ preference_one.id, preference_two.id ]
      person.save
    end

    context "and the order is changed" do

      before do
        person.preference_ids = [ preference_two.id, preference_one.id ]
        person.save
      end

      let(:reloaded) do
        Person.find(person.id)
      end

      it "persists the change in id order" do
        reloaded.preference_ids.should eq(
          [ preference_two.id, preference_one.id ]
        )
      end
    end

    context "and the order is changed and an element is added" do

      let(:preference_three) do
        Preference.create(name: "three")
      end

      before do
        person.preference_ids =
          [ preference_two.id, preference_one.id, preference_three.id ]
        person.save
      end

      let(:reloaded) do
        Person.find(person.id)
      end

      it "also persists the change in id order" do
        reloaded.preference_ids.should eq(
          [ preference_two.id, preference_one.id, preference_three.id ]
        )
      end
    end

    context "and the order is changed and an element is removed" do

      let(:preference_three) do
        Preference.create(name: "three")
      end

      before do
        person.preference_ids =
          [ preference_one.id, preference_two.id, preference_three.id ]
        person.save
        person.preference_ids =
          [ preference_three.id, preference_two.id ]
        person.save
      end

      let(:reloaded) do
        Person.find(person.id)
      end

      it "also persists the change in id order" do
        reloaded.preference_ids.should eq(
          [ preference_three.id, preference_two.id ]
        )
      end
    end
  end

  context "when adding a document" do

    let(:person) do
      Person.new
    end

    let(:preference_one) do
      Preference.new
    end

    let(:first_add) do
      person.preferences.push(preference_one)
    end

    context "when chaining a second add" do

      let(:preference_two) do
        Preference.new
      end

      let(:result) do
        first_add.push(preference_two)
      end

      it "adds both documents" do
        result.should eq([ preference_one, preference_two ])
      end
    end
  end

  context "when setting the relation via the foreign key" do

    context "when the relation exists" do

      let!(:person) do
        Person.create
      end

      let!(:pref_one) do
        person.preferences.create
      end

      let!(:pref_two) do
        Preference.create
      end

      before do
        person.preference_ids = [ pref_two.id ]
      end

      it "sets the new documents on the relation" do
        person.preferences.should eq([ pref_two ])
      end
    end
  end

  context "when using a different primary key" do

    let(:dog) do
      Dog.create(name: 'Doggie')
    end

    let(:cat) do
      Cat.create(name: 'Kitty')
    end

    let(:fire_hydrant) do
      FireHydrant.create(location: '221B Baker Street')
    end

    context "when adding to a one-way many to many" do

      before do
        fire_hydrant.cats.push(cat)
      end

      it "adds the pk value to the fk set" do
        expect(fire_hydrant.cat_ids).to eq([cat.name])
      end
    end

    context "when adding to a two-way many to many" do

      before do
        fire_hydrant.dogs.push(dog)
      end

      it "adds the pk value to the fk set" do
        expect(fire_hydrant.dog_ids).to eq([dog.name])
      end

      it "adds the base pk value to the inverse fk set" do
        expect(dog.fire_hydrant_ids).to eq([fire_hydrant.location])
      end
    end

    context "when deleting from a two-way many to many" do

      before do
        dog.fire_hydrants.push(fire_hydrant)
        fire_hydrant.dogs.delete(dog)
      end

      it "removes the pk value from the fk set" do
        expect(fire_hydrant.dog_ids).to eq([])
      end

      it "removes the base pk value from the inverse fk set" do
        expect(dog.fire_hydrant_ids).to eq([])
      end
    end
  end
end