mongoid-slug 5.2.0 → 5.3.0

data/lib/mongoid/slug/index.rb

@@ -6,15 +6,42 @@ module Mongoid
       #
       # @return [ Array(Hash, Hash) ] the indexable fields and index options.
       def self.build_index(scope_key = nil, by_model_type = false)
-        fields  = { _slugs: 1 }
-        options = {}
-
-        fields.merge!(scope_key => 1) if scope_key
+        # The order of field keys is intentional.
+        # See: http://docs.mongodb.org/manual/core/index-compound/
+        fields = {}
+        fields[:_type] = 1       if by_model_type
+        fields[scope_key] = 1 if scope_key
+        fields[:_slugs] = 1
 
-        if by_model_type
-          fields.merge!(_type: 1)
-        else
-          options.merge!(unique: true, sparse: true)
+        # By design, we use the unique index constraint when possible to enforce slug uniqueness.
+        # When migrating legacy data to Mongoid slug, the _slugs field may be null on many records,
+        # hence we set the sparse index option to ignore these from the unique index.
+        # See: http://docs.mongodb.org/manual/core/index-sparse/
+        #
+        # There are three edge cases where the index must not be unique:
+        #
+        # 1) Legacy tables with `scope_key`. The sparse indexes on compound keys (scope + _slugs) are
+        #    whenever ANY of the key values are present (e.g. when scope is set and _slugs is unset),
+        #    and collisions will occur when multiple records have the same scope but null slugs.
+        #
+        # 2) Single Table Inheritance (`by_model_type`). MongoDB creates indexes on the parent collection,
+        #    irrespective of how STI is defined in Mongoid, i.e. ANY child index will be applied to EVERY child.
+        #    This can cause collisions using various combinations of scopes.
+        #
+        # 3) Paranoid docs rely on sparse indexes to exclude paranoid-deleted records
+        #    from the unique index constraint (i.e. when _slugs is unset.) However, when
+        #    using compound keys (`by_model_type` or `scope_key`), paranoid-deleted records
+        #    can become inadvertently indexed when _slugs is unset, causing duplicates. This
+        #    is already covered by #1 and #2 above.
+        #
+        # In the future, MongoDB may implement partial indexes or improve sparse index behavior.
+        # See: https://jira.mongodb.org/browse/SERVER-785
+        #      https://jira.mongodb.org/browse/SERVER-13780
+        #      https://jira.mongodb.org/browse/SERVER-10403
+        options = {}
+        unless scope_key || by_model_type
+          options[:unique] = true
+          options[:sparse] = true
         end
 
         [fields, options]

data/lib/mongoid/slug/unique_slug.rb

@@ -62,8 +62,8 @@ module Mongoid
       attr_reader :model, :_slug
 
       def_delegators :@model, :slug_scope, :reflect_on_association, :read_attribute,
-                     :check_against_id, :reserved_words, :url_builder, :collection_name,
-                     :embedded?, :reflect_on_all_associations, :by_model_type, :slug_max_length
+                     :check_against_id, :slug_reserved_words, :slug_url_builder, :collection_name,
+                     :embedded?, :reflect_on_all_associations, :slug_by_model_type, :slug_max_length
 
       def initialize(model)
         @model = model
@@ -80,7 +80,7 @@ module Mongoid
           @_slug = if attempt
                      attempt.to_url
                    else
-                     url_builder.call(model)
+                     slug_url_builder.call(model)
                    end
 
           @_slug = @_slug[0...slug_max_length] if slug_max_length
@@ -100,7 +100,7 @@ module Mongoid
             where_hash[scope] = model.try(:read_attribute, scope)
           end
 
-          if by_model_type == true
+          if slug_by_model_type == true
             where_hash[:_type] = model.try(:read_attribute, :_type)
           end
 
@@ -110,7 +110,7 @@ module Mongoid
           @state.include_slug unless model.class.look_like_slugs?([@_slug])
 
           # make sure that the slug is not equal to a reserved word
-          @state.include_slug if reserved_words.any? { |word| word === @_slug }
+          @state.include_slug if slug_reserved_words.any? { |word| word === @_slug }
 
           # only look for a new unique slug if the existing slugs contains the current slug
           # - e.g if the slug 'foo-2' is taken, but 'foo' is available, the user can use 'foo'.

data/lib/mongoid/slug/version.rb

@@ -1,5 +1,5 @@
 module Mongoid #:nodoc:
   module Slug
-    VERSION = '5.2.0'
+    VERSION = '5.3.0'.freeze
   end
 end

data/lib/tasks/mongoid_slug.rake

@@ -3,6 +3,7 @@ namespace :mongoid_slug do
   task set: :environment do |_, args|
     ::Rails.application.eager_load! if defined?(Rails)
     klasses = Module.constants.find_all do |const|
+      next if const == :MissingSourceFile
       const != const.upcase ? Mongoid::Slug > (Object.const_get const) : nil
     end
     klasses.map! { |klass| klass.to_s.constantize }
@@ -11,7 +12,7 @@ namespace :mongoid_slug do
       klasses = (klasses.map(&:to_s) & models.map(&:classify)).map(&:constantize) if models.any?
       klasses.each do |klass|
         # set slug for objects having blank slug
-        klass.each { |object| object.set_slug! unless object.slugs? }
+        klass.each { |object| object.set_slug! unless object.slugs? && object.slugs.any? }
       end
     end
   end

data/spec/models/author.rb

@@ -3,9 +3,13 @@ class Author
   include Mongoid::Slug
   field :first_name
   field :last_name
-  slug :first_name, :last_name, scope: :book, history: false, max_length: 256
-  belongs_to :book
+  if Mongoid::Compatibility::Version.mongoid6?
+    belongs_to :book, required: false
+  else
+    belongs_to :book
+  end
   has_many :characters,
            class_name: 'Person',
            foreign_key: :author_id
+  slug :first_name, :last_name, scope: :book, history: false, max_length: 256
 end

data/spec/models/author_polymorphic.rb

@@ -4,7 +4,11 @@ class AuthorPolymorphic
   field :first_name
   field :last_name
   slug :first_name, :last_name, scope: :book_polymorphic
-  belongs_to :book_polymorphic
+  if Mongoid::Compatibility::Version.mongoid6?
+    belongs_to :book_polymorphic, required: false
+  else
+    belongs_to :book_polymorphic
+  end
   has_many :characters,
            class_name: 'Person',
            foreign_key: :author_id

data/spec/models/paranoid_permanent.rb

@@ -4,5 +4,7 @@ class ParanoidPermanent
   include Mongoid::Slug
 
   field :title
-  slug :title, permanent: true
+  field :foo
+
+  slug :title, scope: :foo, permanent: true
 end

data/spec/models/person.rb

@@ -4,5 +4,9 @@ class Person
   field :name
   slug :name, permanent: true, scope: :author
   embeds_many :relationships
-  belongs_to :author, inverse_of: :characters
+  if Mongoid::Compatibility::Version.mongoid6?
+    belongs_to :author, inverse_of: :characters, required: false
+  else
+    belongs_to :author, inverse_of: :characters
+  end
 end

data/spec/mongoid/index_spec.rb

@@ -11,17 +11,19 @@ describe Mongoid::Slug::Index do
 
     context 'when by_model_type is true' do
       let(:by_model_type) { true }
+
       it { is_expected.to eq [{ _slugs: 1, foo: 1, _type: 1 }, {}] }
     end
 
     context 'when by_model_type is false' do
-      it { is_expected.to eq [{ _slugs: 1, foo: 1 }, { unique: true, sparse: true }] }
+      it { is_expected.to eq [{ _slugs: 1, foo: 1 }, {}] }
     end
   end
 
   context 'when scope_key is not set' do
     context 'when by_model_type is true' do
       let(:by_model_type) { true }
+
       it { is_expected.to eq [{ _slugs: 1, _type: 1 }, {}] }
     end
 

data/spec/mongoid/paranoia_spec.rb

@@ -2,10 +2,78 @@
 require 'spec_helper'
 
 describe 'Mongoid::Paranoia with Mongoid::Slug' do
+  let(:paranoid_doc)    { ParanoidDocument.create!(title: 'slug') }
+  let(:paranoid_doc_2)  { ParanoidDocument.create!(title: 'slug') }
+  let(:paranoid_perm)   { ParanoidPermanent.create!(title: 'slug') }
+  let(:paranoid_perm_2) { ParanoidPermanent.create!(title: 'slug') }
+  let(:non_paranoid_doc) { Article.create!(title: 'slug') }
+  subject { paranoid_doc }
+
+  describe '.paranoid?' do
+    context 'when Mongoid::Paranoia is included' do
+      subject { paranoid_doc.class }
+      specify { expect(subject.is_paranoid_doc?).to be true }
+    end
+
+    context 'when Mongoid::Paranoia not included' do
+      subject { non_paranoid_doc.class }
+      specify { expect(subject.is_paranoid_doc?).to be false }
+    end
+  end
+
+  describe '#paranoid_deleted?' do
+    context 'when Mongoid::Paranoia is included' do
+      context 'when not destroyed' do
+        specify { expect(subject.paranoid_deleted?).to be false }
+      end
+
+      context 'when destroyed' do
+        before { subject.destroy }
+        specify { expect(subject.paranoid_deleted?).to be true }
+      end
+    end
+
+    context 'when Mongoid::Paranoia not included' do
+      subject { non_paranoid_doc }
+      specify { expect(subject.paranoid_deleted?).to be false }
+    end
+  end
+
+  describe 'restore callbacks' do
+    context 'when Mongoid::Paranoia is included' do
+      subject { paranoid_doc.class }
+      it { is_expected.to respond_to(:before_restore) }
+      it { is_expected.to respond_to(:after_restore) }
+    end
+
+    context 'when Mongoid::Paranoia not included' do
+      it { is_expected.to_not respond_to(:before_restore) }
+      it { is_expected.to_not respond_to(:after_restore) }
+    end
+  end
+
+  describe 'index' do
+    context 'simple index' do
+      before  { ParanoidDocument.create_indexes }
+      after   { ParanoidDocument.remove_indexes }
+      subject { ParanoidDocument }
+
+      it_should_behave_like 'has an index', { _slugs: 1 }, unique: true, sparse: true
+    end
+
+    context 'compound index' do
+      before  { ParanoidPermanent.create_indexes }
+      after   { ParanoidPermanent.remove_indexes }
+      subject { ParanoidPermanent }
+
+      it_should_behave_like 'has an index', { foo: 1, _slugs: 1 }, unique: nil, sparse: nil
+    end
+  end
+
   shared_examples_for 'paranoid slugs' do
     context 'querying' do
       it 'returns paranoid_doc for correct slug' do
-        expect(subject.class.find(subject.slug)).to eq(subject)
+        expect(subject.class.find(subject.slug)).to eq subject
       end
     end
 
@@ -27,8 +95,8 @@ describe 'Mongoid::Paranoia with Mongoid::Slug' do
       end
 
       it 'persists the removed slug' do
-        expect(subject.reload._slugs).to eq []
-        expect(subject.reload.slug).to be_nil
+        expect(subject.reload._slugs).to be nil
+        expect(subject.reload.slug).to eq subject._id.to_s
       end
 
       it 'persists the removed slug in the database' do
@@ -67,7 +135,7 @@ describe 'Mongoid::Paranoia with Mongoid::Slug' do
       it 'new documents should be able to use the slug of destroyed documents' do
         expect(subject.slug).to eq 'slug'
         subject.destroy
-        expect(subject.reload.slug).to be_nil
+        expect(subject.reload.slug).to eq subject._id.to_s
         expect(other_doc.slug).to eq 'slug'
         subject.restore
         expect(subject.slug).to eq 'slug-1'
@@ -77,16 +145,16 @@ describe 'Mongoid::Paranoia with Mongoid::Slug' do
       it 'should allow multiple documents to be destroyed without index conflict' do
         expect(subject.slug).to eq 'slug'
         subject.destroy
-        expect(subject.reload.slug).to be_nil
+        expect(subject.reload.slug).to eq subject._id.to_s
         expect(other_doc.slug).to eq 'slug'
         other_doc.destroy
-        expect(other_doc.reload.slug).to be_nil
+        expect(other_doc.reload.slug).to eq other_doc._id.to_s
       end
     end
   end
 
   [ParanoidDocument, DocumentParanoid].each do |paranoid_klass|
-    context "#{paranoid_klass}" do
+    context paranoid_klass.to_s do
       let(:paranoid_doc) { paranoid_klass.create!(title: 'slug') }
       let(:non_paranoid_doc) { Article.create!(title: 'slug') }
 
@@ -95,30 +163,30 @@ describe 'Mongoid::Paranoia with Mongoid::Slug' do
       describe '.paranoid?' do
         context 'when Mongoid::Paranoia is included' do
           subject { paranoid_doc.class }
-          its(:is_paranoid_doc?) { should be_truthy }
+          its(:is_paranoid_doc?) { is_expected.to be_truthy }
         end
 
         context 'when Mongoid::Paranoia not included' do
           subject { non_paranoid_doc.class }
-          its(:is_paranoid_doc?) { should be_falsey }
+          its(:is_paranoid_doc?) { is_expected.to be_falsey }
         end
       end
 
       describe '#paranoid_deleted?' do
         context 'when Mongoid::Paranoia is included' do
           context 'when not destroyed' do
-            its(:paranoid_deleted?) { should be_falsey }
+            its(:paranoid_deleted?) { is_expected.to be_falsey }
           end
 
           context 'when destroyed' do
             before { subject.destroy }
-            its(:paranoid_deleted?) { should be_truthy }
+            its(:paranoid_deleted?) { is_expected.to be_truthy }
           end
         end
 
         context 'when Mongoid::Paranoia not included' do
           subject { non_paranoid_doc }
-          its(:paranoid_deleted?) { should be_falsey }
+          its(:paranoid_deleted?) { is_expected.to be_falsey }
         end
       end
 

data/spec/mongoid/slug_spec.rb

@@ -7,8 +7,8 @@ module Mongoid
       Book.create(title: 'A Thousand Plateaus')
     end
 
-    context 'should not persist incorrect slugs' do
-      it 'slugs should not be generated from invalid documents' do
+    context 'special cases' do
+      it 'slugs are not be generated from invalid documents' do
         # this will fail now
         x = IncorrectSlugPersistence.create!(name: 'test')
         expect(x.slug).to eq('test')
@@ -23,9 +23,33 @@ module Mongoid
         x.save!
       end
 
-      it "doesn't persist blank strings" do
+      it 'has no slugs for blank strings' do
         book = Book.create!(title: '')
-        expect(book.reload.slugs).to be_empty
+        expect(book.reload.slugs).to be nil
+      end
+
+      it 'has no slugs for dashes' do
+        book = Book.create!(title: '-')
+        expect(book.reload.slugs).to be nil
+      end
+
+      it 'has no slugs for underscores' do
+        book = Book.create!(title: '_')
+        expect(book.reload.slugs).to be nil
+      end
+
+      it 'has no slugs for nil strings' do
+        book = Book.create!
+        expect(book.reload.slugs).to be nil
+      end
+
+      it 'works for multiple nils' do
+        expect do
+          2.times do
+            Book.create!
+          end
+        end.to_not raise_error # Mongo::Error::OperationFailure
+        expect(Book.all.map(&:slug)).to eq Book.all.map(&:id).map(&:to_s)
       end
     end
 
@@ -271,7 +295,8 @@ module Mongoid
       let!(:author) do
         Author.create(
           first_name: 'Gilles',
-          last_name: 'Deleuze')
+          last_name: 'Deleuze'
+        )
       end
 
       it 'generates a slug' do
@@ -288,12 +313,14 @@ module Mongoid
       it 'generates a unique slug by appending a counter to duplicate text' do
         dup = Author.create(
           first_name: author.first_name,
-          last_name: author.last_name)
+          last_name: author.last_name
+        )
         expect(dup.to_param).to eql 'gilles-deleuze-1'
 
         dup2 = Author.create(
           first_name: author.first_name,
-          last_name: author.last_name)
+          last_name: author.last_name
+        )
 
         dup.save
         expect(dup2.to_param).to eql 'gilles-deleuze-2'
@@ -412,7 +439,8 @@ module Mongoid
       it 'generates a unique slug by appending a counter to duplicate text' do
         dup = book.authors.create(
           first_name: author.first_name,
-          last_name: author.last_name)
+          last_name: author.last_name
+        )
         expect(dup.to_param).to eql 'gilles-deleuze-1'
       end
 
@@ -488,6 +516,54 @@ module Mongoid
       end
     end
 
+    context 'when block is configured globally' do
+      before do
+        Mongoid::Slug.configure do |c|
+          c.slug do |cur_obj|
+            slug = cur_obj.slug_builder
+            "#{slug}-#{cur_obj.id}".to_url
+          end
+        end
+      end
+
+      after do
+        # Remove global configuration to avoid affect on
+        # other specs run after this spec
+        Mongoid::Slug.default_slug = nil
+        expect(Mongoid::Slug.default_slug).to be_nil
+      end
+
+      it 'generates a slug' do
+        expect(Mongoid::Slug.default_slug).to be_present
+        class Person
+          include Mongoid::Document
+          include Mongoid::Slug
+
+          field :name
+          slug :name
+        end
+
+        person = Person.create(name: 'John')
+        expect(person.to_param).to eql "john-#{person.id}"
+      end
+
+      it 'can be overridden at model level' do
+        expect(Mongoid::Slug.default_slug).to be_present
+        class Person
+          include Mongoid::Document
+          include Mongoid::Slug
+
+          field :name
+          slug :name do |cur_object|
+            cur_object.slug_builder.to_url
+          end
+        end
+
+        person = Person.create(name: 'John')
+        expect(person.to_param).to eql 'john'
+      end
+    end
+
     context 'when slugged field contains non-ASCII characters' do
       it 'slugs Cyrillic characters' do
         book.title = 'Капитал'
@@ -514,126 +590,108 @@ module Mongoid
       end
     end
 
-    context 'when indexes are created' do
-      before do
-        Author.create_indexes
-        Book.create_indexes
+    context 'when slug is not scoped by a reference association' do
+      subject { Book }
+      it_should_behave_like 'has an index', { _slugs: 1 }, unique: true, sparse: true
+    end
 
-        AuthorPolymorphic.create_indexes
-        BookPolymorphic.create_indexes
+    context 'with a value exceeding mongodb max index key' do
+      if Mongoid::Compatibility::Version.mongoid5? || Mongoid::Compatibility::Version.mongoid6?
+        it 'errors with a model without a max length' do
+          expect do
+            Book.create!(title: 't' * 1025)
+          end.to raise_error Mongo::Error::OperationFailure, /key too large to index/
+        end
+      elsif Mongoid::Compatibility::Version.mongoid4?
+        it 'errors with a model without a max length' do
+          expect do
+            Book.create!(title: 't' * 1025)
+          end.to raise_error Moped::Errors::OperationFailure, /key too large to index/
+        end
       end
-
-      after do
-        Author.remove_indexes
-        Book.remove_indexes
-
-        AuthorPolymorphic.remove_indexes
-        BookPolymorphic.remove_indexes
+      it 'succeeds with a model with a max length' do
+        expect do
+          author = Author.create!(last_name: 't' * 1025)
+          expect(author.slug.length).to eq 256
+        end.to_not raise_error
       end
+    end
 
-      context 'when slug is not scoped by a reference association' do
-        subject { Book }
-        it_should_behave_like 'has an index', { _slugs: 1 }, unique: true, sparse: true
-      end
+    context 'when slug is scoped by a reference association' do
+      subject { Author }
+      it_should_behave_like 'does not have an index', _slugs: 1
+    end
 
-      context 'with a value exceeding mongodb max index key' do
-        if Mongoid::Compatibility::Version.mongoid5?
-          it 'errors with a model without a max length' do
-            expect do
-              Book.create!(title: 't' * 1025)
-            end.to raise_error Mongo::Error::OperationFailure, /key too large to index/
-          end
-        elsif Mongoid::Compatibility::Version.mongoid4?
-          it 'errors with a model without a max length' do
-            expect do
-              Book.create!(title: 't' * 1025)
-            end.to raise_error Moped::Errors::OperationFailure, /key too large to index/
-          end
-        end
-        it 'succeeds with a model with a max length' do
-          expect do
-            author = Author.create!(last_name: 't' * 1025)
-            expect(author.slug.length).to eq 256
-          end.to_not raise_error
-        end
+    context 'for subclass scope' do
+      context 'when slug is not scoped by a reference association' do
+        subject { BookPolymorphic }
+        it_should_behave_like 'has an index', { _type: 1, _slugs: 1 }, unique: nil, sparse: nil
       end
 
       context 'when slug is scoped by a reference association' do
-        subject { Author }
-        it_should_behave_like 'does not have an index', _slugs: 1
+        subject { AuthorPolymorphic }
+        it_should_behave_like 'does not have an index', _type: 1, _slugs: 1
       end
 
-      context 'for subclass scope' do
-        context 'when slug is not scoped by a reference association' do
-          subject { BookPolymorphic }
-          it_should_behave_like 'has an index', { _type: 1, _slugs: 1 }, unique: nil, sparse: nil
-        end
-
-        context 'when slug is scoped by a reference association' do
-          subject { AuthorPolymorphic }
-          it_should_behave_like 'does not have an index', _type: 1, _slugs: 1
-        end
-
-        context 'when the object has STI' do
-          it 'scopes by the subclass' do
-            b = BookPolymorphic.create!(title: 'Book')
-            expect(b.slug).to eq('book')
+      context 'when the object has STI' do
+        it 'scopes by the subclass' do
+          b = BookPolymorphic.create!(title: 'Book')
+          expect(b.slug).to eq('book')
 
-            b2 = BookPolymorphic.create!(title: 'Book')
-            expect(b2.slug).to eq('book-1')
+          b2 = BookPolymorphic.create!(title: 'Book')
+          expect(b2.slug).to eq('book-1')
 
-            c = ComicBookPolymorphic.create!(title: 'Book')
-            expect(c.slug).to eq('book')
+          c = ComicBookPolymorphic.create!(title: 'Book')
+          expect(c.slug).to eq('book')
 
-            c2 = ComicBookPolymorphic.create!(title: 'Book')
-            expect(c2.slug).to eq('book-1')
+          c2 = ComicBookPolymorphic.create!(title: 'Book')
+          expect(c2.slug).to eq('book-1')
 
-            expect(BookPolymorphic.find('book')).to eq(b)
-            expect(BookPolymorphic.find('book-1')).to eq(b2)
-            expect(ComicBookPolymorphic.find('book')).to eq(c)
-            expect(ComicBookPolymorphic.find('book-1')).to eq(c2)
-          end
+          expect(BookPolymorphic.find('book')).to eq(b)
+          expect(BookPolymorphic.find('book-1')).to eq(b2)
+          expect(ComicBookPolymorphic.find('book')).to eq(c)
+          expect(ComicBookPolymorphic.find('book-1')).to eq(c2)
         end
       end
     end
+  end
 
-    context 'for reserved words' do
-      context 'when the :reserve option is used on the model' do
-        it 'does not use the reserved slugs' do
-          friend1 = Friend.create(name: 'foo')
-          expect(friend1.slugs).not_to include('foo')
-          expect(friend1.slugs).to include('foo-1')
+  context 'for reserved words' do
+    context 'when the :reserve option is used on the model' do
+      it 'does not use the reserved slugs' do
+        friend1 = Friend.create(name: 'foo')
+        expect(friend1.slugs).not_to include('foo')
+        expect(friend1.slugs).to include('foo-1')
 
-          friend2 = Friend.create(name: 'bar')
-          expect(friend2.slugs).not_to include('bar')
-          expect(friend2.slugs).to include('bar-1')
+        friend2 = Friend.create(name: 'bar')
+        expect(friend2.slugs).not_to include('bar')
+        expect(friend2.slugs).to include('bar-1')
 
-          friend3 = Friend.create(name: 'en')
-          expect(friend3.slugs).not_to include('en')
-          expect(friend3.slugs).to include('en-1')
-        end
+        friend3 = Friend.create(name: 'en')
+        expect(friend3.slugs).not_to include('en')
+        expect(friend3.slugs).to include('en-1')
+      end
 
-        it 'should start with concatenation -1' do
-          friend1 = Friend.create(name: 'foo')
-          expect(friend1.slugs).to include('foo-1')
-          friend2 = Friend.create(name: 'foo')
-          expect(friend2.slugs).to include('foo-2')
-        end
+      it 'should start with concatenation -1' do
+        friend1 = Friend.create(name: 'foo')
+        expect(friend1.slugs).to include('foo-1')
+        friend2 = Friend.create(name: 'foo')
+        expect(friend2.slugs).to include('foo-2')
+      end
 
-        %w(new edit).each do |word|
-          it "should overwrite the default reserved words allowing the word '#{word}'" do
-            friend = Friend.create(name: word)
-            expect(friend.slugs).to include word
-          end
+      %w(new edit).each do |word|
+        it "should overwrite the default reserved words allowing the word '#{word}'" do
+          friend = Friend.create(name: word)
+          expect(friend.slugs).to include word
         end
       end
-      context 'when the model does not have any reserved words set' do
-        %w(new edit).each do |word|
-          it "does not use the default reserved word '#{word}'" do
-            book = Book.create(title: word)
-            expect(book.slugs).not_to include word
-            expect(book.slugs).to include("#{word}-1")
-          end
+    end
+    context 'when the model does not have any reserved words set' do
+      %w(new edit).each do |word|
+        it "does not use the default reserved word '#{word}'" do
+          book = Book.create(title: word)
+          expect(book.slugs).not_to include word
+          expect(book.slugs).to include("#{word}-1")
         end
       end
     end
@@ -667,7 +725,7 @@ module Mongoid
         let(:book) { Book.new }
 
         it 'should return nil' do
-          expect(book.to_param).to be_nil
+          expect(book.to_param).to eq book._id.to_s
         end
 
         it 'should not persist the record' do
@@ -677,24 +735,22 @@ module Mongoid
       end
 
       context 'when called on an existing record with no slug' do
-        let!(:book_no_title) { Book.create }
-
-        before do
-          if Mongoid::Compatibility::Version.mongoid5?
+        let!(:book_no_slug) do
+          if Mongoid::Compatibility::Version.mongoid5? || Mongoid::Compatibility::Version.mongoid6?
             Book.collection.insert_one(title: 'Proust and Signs')
           else
             Book.collection.insert(title: 'Proust and Signs')
           end
+          Book.where(title: 'Proust and Signs').first
         end
 
         it 'should return the id if there is no slug' do
-          book = Book.first
-          expect(book.to_param).to eq(book.id.to_s)
-          expect(book.reload.slugs).to be_empty
+          expect(book_no_slug.to_param).to eq(book_no_slug.id.to_s)
+          expect(book_no_slug.slugs).to be_nil
         end
 
         it 'should not persist the record' do
-          expect(book_no_title.to_param).to eq(book_no_title._id.to_s)
+          expect(book_no_slug.to_param).to eq(book_no_slug._id.to_s)
         end
       end
     end
@@ -738,9 +794,17 @@ module Mongoid
         end
 
         it 'ensures uniqueness' do
-          Book.create(title: 'A Thousand Plateaus', slugs: ['not-what-you-expected'])
-          book2 = Book.create(title: 'A Thousand Plateaus', slugs: ['not-what-you-expected'])
-          expect(book2.to_param).to eql 'not-what-you-expected-1'
+          book1 = Book.create(title: 'A Thousand Plateaus', slugs: ['not-what-you-expected'])
+          expect(book1.to_param).to eql 'not-what-you-expected'
+          if Mongoid::Compatibility::Version.mongoid5? || Mongoid::Compatibility::Version.mongoid6?
+            expect do
+              Book.create(title: 'A Thousand Plateaus', slugs: ['not-what-you-expected'])
+            end.to raise_error Mongo::Error::OperationFailure, /duplicate/
+          elsif Mongoid::Compatibility::Version.mongoid4?
+            expect do
+              Book.create(title: 'A Thousand Plateaus', slugs: ['not-what-you-expected'])
+            end.to raise_error Moped::Errors::OperationFailure, /duplicate/
+          end
         end
 
         it 'updates the slug when a new one is passed in' do
@@ -761,8 +825,15 @@ module Mongoid
           Book.create(title: 'Sleepyhead')
           book2 = Book.create(title: 'A Thousand Plateaus')
           book2.slugs.push 'sleepyhead'
-          book2.save
-          expect(book2.to_param).to eql 'sleepyhead-1'
+          if Mongoid::Compatibility::Version.mongoid5? || Mongoid::Compatibility::Version.mongoid6?
+            expect do
+              book2.save
+            end.to raise_error Mongo::Error::OperationFailure, /duplicate/
+          elsif Mongoid::Compatibility::Version.mongoid4?
+            expect do
+              book2.save
+            end.to raise_error Moped::Errors::OperationFailure, /duplicate/
+          end
         end
       end
 
@@ -1087,5 +1158,13 @@ module Mongoid
         expect(author3.slug.ends_with?('tt-2')).to be true
       end
     end
+
+    context 'has_many / belongs_to' do
+      let(:book) { Book.create!(title: 'War and Peace') }
+      it 'allows for duplicates with different slugs' do
+        Author.create!(first_name: 'Leo', last_name: 'Tostoy')
+        expect { book.authors.create!(first_name: 'Leo', last_name: 'Tostoy') }.to_not raise_error
+      end
+    end
   end
 end