mongoid-rspec 4.2.0 → 4.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 711f91347b02d3d6982a72b6946bb781ea07dba16f858109da01166c7a768ecf
-  data.tar.gz: 58e81131678e670e5a7b63385122fa316afadb18d49749c3544a4e5e1898d3fc
+  metadata.gz: 2ac3e47b3e606516f4ca239dad1405872db4cd012443a11a9e3c332d47555c27
+  data.tar.gz: 8b4d8baff373f7b2c6bc7e194a5a21192c08bdfda17e40693e300f9fd48a111b
 SHA512:
-  metadata.gz: 7aab1843f0f0b8778916039f3ef8b0f89e815bbc9cfafe0d7244a903df8c524ec6e990914478d6cd403b5b9e81e885b007850fe58cbf78841d989a472e98cdb2
-  data.tar.gz: 3e068496db19d24acfd05ff8ac630ecd41ccab1606e6597ddf0d0bf5969296dd7e1f2f5cf3a7a847801b44c84363e784908024a392317b7d1a95825f2c66bf9f
+  metadata.gz: 51157b3c68734d119c2880e7d071f52f244322bf517bfd8cab697d0e2f2e0662877b455acf704923dbed3f24034ab341c4c84ad6a9443230370052f805c6db0e
+  data.tar.gz: 0ed7c718a2862d4a1bb5abfd03e430dff67b1589612abbf50b2f449dd0584ecaff99b42b8e204e6281eab65f1b404b1bbf710da65550bd4fb369ef157395b241

data/README.md

@@ -1,12 +1,15 @@
 # [mongoid-rspec](https://github.com/mongoid/mongoid-rspec "A collection of RSpec-compatible matchers that help to test Mongoid documents.")
 
 [![Gem Version](https://badge.fury.io/rb/mongoid-rspec.svg)](https://badge.fury.io/rb/mongoid-rspec)
-[![Test Status](https://github.com/mongoid/mongoid-rspec/workflows/Test/badge.svg)](https://github.com/mongoid/mongoid-rspec/actions)
-[![Rubocop Status](https://github.com/mongoid/mongoid-rspec/workflows/Rubocop/badge.svg)](https://github.com/mongoid/mongoid-rspec/actions)
+[![Test Status](https://github.com/mongoid/mongoid-rspec/actions/workflows/rspec.yml/badge.svg?branch=master)](https://github.com/mongoid/mongoid-rspec/actions/workflows/rspec.yml?query=branch%3Amaster)
+[![Rubocop Status](https://github.com/mongoid/mongoid-rspec/actions/workflows/rubocop.yml/badge.svg?branch=master)](https://github.com/mongoid/mongoid-rspec/actions/workflows/rubocop.yml?query=branch%3Amaster)
+[![Coverage Status](https://coveralls.io/repos/github/mongoid/mongoid-rspec/badge.svg?branch=master)](https://coveralls.io/github/mongoid/mongoid-rspec?branch=master)
+
+CI collects SimpleCov coverage on Ruby 3.4 with Mongoid 9 and MongoDB 8.0 and submits one report to Coveralls using GitHub's workflow token. To generate a local report, run `COVERAGE=true BUNDLE_GEMFILE=gemfiles/mongoid_9.gemfile bundle install` followed by `COVERAGE=true BUNDLE_GEMFILE=gemfiles/mongoid_9.gemfile bundle exec rake spec`. Reports are written to `coverage/`.
 
 The mongoid-rspec library provides a collection of RSpec-compatible matchers that help to test Mongoid documents.
 
-[Tested](https://github.com/mongoid/mongoid-locker/actions) against:
+[Tested](https://github.com/mongoid/mongoid-rspec/actions/workflows/rspec.yml) against:
 - MRI: `2.6.x`, `2.7.x`, `3.0.x`, `3.1.x`, `3.2.x`
 - Mongoid: `4`, `5`, `6`, `7`, `8`, `9`
 
@@ -41,6 +44,33 @@ RSpec.configure do |config|
 end
 ```
 
+### Using Mongoid and ActiveRecord with shoulda-matchers
+
+Both libraries define matcher names such as `validate_length_of` and `belong_to`, but their chain methods and implementations differ. In an application with both Mongoid and ActiveRecord models, include Mongoid matchers only for a custom `:mongoid_model` type instead of all `:model` examples. Keep Shoulda's ActiveModel and ActiveRecord matchers scoped to `:model`:
+
+```ruby
+require 'mongoid-rspec'
+require 'shoulda/matchers'
+
+RSpec.configure do |config|
+  config.include Mongoid::Matchers, type: :mongoid_model
+  config.include Shoulda::Matchers::ActiveModel, type: :model
+  config.include Shoulda::Matchers::ActiveRecord, type: :model
+end
+
+RSpec.describe MongoidAddress, type: :mongoid_model do
+  it { is_expected.to validate_length_of(:name).with_maximum(255) }
+  it { is_expected.to belong_to(:city).as_inverse_of(:addresses) }
+end
+
+RSpec.describe ActiveRecordAddress, type: :model do
+  it { is_expected.to validate_length_of(:name).is_at_most(255) }
+  it { is_expected.to belong_to(:city).inverse_of(:addresses) }
+end
+```
+
+Replace the existing unscoped or `type: :model` inclusion of `Mongoid::Matchers`; do not keep it alongside the scoped configuration. Explicitly tag Mongoid example groups with `type: :mongoid_model`, including those under `spec/models`, where rspec-rails would otherwise infer `:model`. Do not include Shoulda's model matcher modules globally or directly in those Mongoid groups. This avoids depending on module inclusion order and preserves each library's existing matcher API.
+
 ### Other
 
 Add to your `spec_helper.rb` file.
@@ -204,8 +234,74 @@ RSpec.describe Article, type: :model do
 end
 ```
 
+### execute_mongodb_command
+
+Use `execute_mongodb_command` with a block expectation to verify that code issues a MongoDB command. Without an argument, the matcher passes when any command is issued on the block's thread. An expected command matches the entire application command document exactly, not just a subset or query selector; nested String and Symbol keys are normalized to Strings. Driver-added top-level `$db`, `lsid`, and `$clusterTime` fields are excluded from comparison, while all other command fields and values must match. The matcher ignores unrelated background-thread activity and raises `NotImplementedError` when the driver does not expose command monitoring, including the legacy driver used with Mongoid 4.
+
+```ruby
+RSpec.describe FooService do
+  it 'uses the cached result without querying MongoDB' do
+    expect { FooService.recent_foos }.not_to execute_mongodb_command
+  end
+end
+
+RSpec.describe Article do
+  it 'executes the expected MongoDB command' do
+    expected_command = {
+      find: 'articles',
+      filter: { 'title.en' => 'cached' },
+      limit: 10,
+      sort: { created_at: -1 }
+    }
+
+    expect do
+      Article.where(title: 'cached').desc(:created_at).limit(10).to_a
+    end.to execute_mongodb_command(expected_command)
+  end
+end
+```
+
+### be_covered_query
+
+Check that MongoDB's winning plan uses an index without fetching documents:
+
+```ruby
+class Article
+  index({ title: 1, _id: 1 })
+end
+
+RSpec.describe Article do
+  it { expect(Article.where(title: 'Example').only(:title)).to be_covered_query }
+end
+```
+
+Mongoid includes `_id` in an inclusive projection by default, so the index must cover it as well. The matcher examines all stages in the winning plan, including nested shard plans, and rejects plans containing `FETCH` or `COLLSCAN`. A covered plan does not guarantee that a query is fast; this matcher checks plan coverage, not execution time.
+
+Use `.using_index('title_1__id_1')` or `.using_indexes('first_index', 'second_index')` to additionally require the exact set of index names used by the winning plan. Index names accept nonempty strings or symbols; order and repeated uses across shards do not matter. Rejected plans are ignored, and the query must still be covered.
+
+```ruby
+expect(Article.where(title: 'Example').only(:title)).to be_covered_query.using_index('title_1__id_1')
+```
+
 ### Field Matchers
 
+Chain `.readonly` to check fields declared with Mongoid's `attr_readonly`. This checks the declaration, not whether a new document currently allows writes. Like other field matcher options, it applies to every requested field and accepts class or instance subjects.
+
+```ruby
+class Article
+  include Mongoid::Document
+
+  field :slug, type: String
+  field :external_id, type: String
+  attr_readonly :slug, :external_id
+end
+
+RSpec.describe Article do
+  it { is_expected.to have_field(:slug).of_type(String).readonly }
+  it { is_expected.to have_fields(:slug, :external_id).readonly }
+end
+```
+
 ```ruby
 RSpec.describe Article do
   it { is_expected.to have_field(:published).of_type(Mongoid::Boolean).with_default_value_of(false) }
@@ -223,6 +319,31 @@ end
 
 ### Association Matchers
 
+Use `with_primary_key` to check an association's primary key, including the default `_id`. Like `with_foreign_key`, it accepts a symbol or string and can be chained with other association options:
+
+```ruby
+class Author
+  include Mongoid::Document
+
+  field :code, type: String
+  has_many :posts, primary_key: :code, foreign_key: :author_code
+end
+
+class Post
+  include Mongoid::Document
+
+  belongs_to :author, primary_key: :code, foreign_key: :author_code
+end
+
+RSpec.describe Author do
+  it { is_expected.to have_many(:posts).with_primary_key(:code).with_foreign_key(:author_code) }
+end
+
+RSpec.describe Post do
+  it { is_expected.to belong_to(:author).with_primary_key('code') }
+end
+```
+
 ```ruby
 RSpec.describe User do
   it { is_expected.to have_many(:articles).with_foreign_key(:author_id).ordered_by(:title) }
@@ -244,6 +365,8 @@ RSpec.describe User do
 
   it { is_expected.to have_and_belong_to_many(:children) }
   it { is_expected.to have_and_belong_to_many(:children).of_type(User) }
+  # nonconflicting alternative when using shoulda-matchers
+  it { is_expected.to have_and_belong_to_many_related(:children).of_type(User) }
 end
 
 RSpec.describe Profile do
@@ -297,6 +420,10 @@ end
 
 ### Validation Matchers
 
+`validate_length_of` searches all applicable length validators for one matching the requested options. For example, a maximum-length validator added by `has_secure_password` does not hide a separately declared minimum-length validator. Chained length, message, and `to_allow` options must match a single validator; options from separate validators are not combined.
+
+Use `validate_length_of(:name).within(1..100).to_allow(nil: true)` to check `allow_nil: true`, or `.to_allow(blank: true)` to check `allow_blank: true`. Both options can be combined, and the full keys `allow_nil` and `allow_blank` are also accepted. Values must be `true` or `false`; `false` requires an explicitly configured `false` (an omitted option does not match). Omitting `to_allow` leaves these options unchecked. Empty hashes, unknown keys, non-boolean values, and duplicate aliases are rejected with `ArgumentError`.
+
 ```ruby
 RSpec.describe Site do
   it { is_expected.to validate_presence_of(:name) }
@@ -393,6 +520,8 @@ end
 
 You're encouraged to contribute to this library. See [CONTRIBUTING](CONTRIBUTING.md) for details.
 
+`bundle exec rake` runs the unit suite without third-party integration dependencies. Each integration has its own Appraisal bundle and directory under `spec/integration/`. For example, run `BUNDLE_GEMFILE=gemfiles/shoulda_matchers.gemfile bundle install`, then `BUNDLE_GEMFILE=gemfiles/shoulda_matchers.gemfile bundle exec rspec spec/integration/shoulda_matchers`. To add an integration, define its dependencies in Appraisals, generate its gemfile, add its specs under a matching directory, and add its name to the integration matrix in `.github/workflows/rspec.yml`. CI runs each listed integration in a separate process and bundle.
+
 ## Copyright and License
 
 Copyright (c) 2009-2018 Evan Sagge and Contributors.

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 $LOAD_PATH.push File.expand_path('../lib', __FILE__)
 
 require 'bundler'
@@ -6,11 +8,11 @@ Bundler::GemHelper.install_tasks
 require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = './spec/**/*_spec.rb'
+  spec.pattern = './spec/unit/**/*_spec.rb'
 end
 
 RSpec::Core::RakeTask.new(:rcov) do |spec|
-  spec.pattern = './spec/**/*_spec.rb'
+  spec.pattern = './spec/unit/**/*_spec.rb'
   spec.rcov = true
 end
 

data/lib/matchers/accept_nested_attributes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Matchers # :nodoc:
     # Ensures that the model can accept nested attributes for the specified

data/lib/matchers/allow_mass_assignment.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # this code is totally extracted from shoulda-matchers gem.
 module Mongoid
   module Matchers

data/lib/matchers/associations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 if Mongoid::Compatibility::Version.mongoid7_or_newer?
   require 'mongoid/association'
 else
@@ -30,7 +32,7 @@ module Mongoid
           @association = {}
           @association[:name] = name.to_s
           @association[:type] = association_type
-          @expectation_message = "#{type_description} #{@association[:name].inspect}"
+          @expectation_message = +"#{type_description} #{@association[:name].inspect}"
           @expectation_message << " of type #{@association[:class].inspect}" unless @association[:class].nil?
         end
 
@@ -113,6 +115,12 @@ module Mongoid
           self
         end
 
+        def with_primary_key(primary_key)
+          @association[:primary_key] = primary_key.to_s
+          @expectation_message << " using primary key #{@association[:primary_key].inspect}"
+          self
+        end
+
         def with_counter_cache
           @association[:counter_cache] = true
           @expectation_message << " which specifies counter_cache as #{@association[:counter_cache]}"
@@ -269,6 +277,15 @@ module Mongoid
             end
           end
 
+          if @association[:primary_key]
+            if metadata.primary_key != @association[:primary_key]
+              @negative_result_message = "#{@positive_result_message} with primary key #{metadata.primary_key.inspect}"
+              return false
+            else
+              @positive_result_message = "#{@positive_result_message} with primary key #{metadata.primary_key.inspect}"
+            end
+          end
+
           if @association[:counter_cache]
             if metadata.counter_cached? != true
               @negative_result_message = "#{@positive_result_message} which did not set counter_cache"
@@ -318,19 +335,19 @@ module Mongoid
           type ||= @association[:type]
           case type.name
           when EMBEDS_ONE.name
-            (passive ? 'embed' : 'embeds') << ' one'
+            +(passive ? 'embed' : 'embeds') << ' one'
           when EMBEDS_MANY.name
-            (passive ? 'embed' : 'embeds') << ' many'
+            +(passive ? 'embed' : 'embeds') << ' many'
           when EMBEDDED_IN.name
-            (passive ? 'be' : 'is') << ' embedded in'
+            +(passive ? 'be' : 'is') << ' embedded in'
           when HAS_ONE.name
-            (passive ? 'reference' : 'references') << ' one'
+            +(passive ? 'reference' : 'references') << ' one'
           when HAS_MANY.name
-            (passive ? 'reference' : 'references') << ' many'
+            +(passive ? 'reference' : 'references') << ' many'
           when HAS_AND_BELONGS_TO_MANY.name
-            (passive ? 'reference' : 'references') << ' and referenced in many'
+            +(passive ? 'reference' : 'references') << ' and referenced in many'
           when BELONGS_TO.name
-            (passive ? 'be referenced in' : 'referenced in')
+            +(passive ? 'be referenced in' : 'referenced in')
           else
             raise format("Unknown association type '%s'", type)
           end
@@ -369,9 +386,10 @@ module Mongoid
       end
       alias have_many have_many_related
 
-      def have_and_belong_to_many(association_name)
+      def have_and_belong_to_many_related(association_name)
         HaveAssociationMatcher.new(association_name, HAS_AND_BELONGS_TO_MANY)
       end
+      alias have_and_belong_to_many have_and_belong_to_many_related
 
       def belong_to_related(association_name)
         HaveAssociationMatcher.new(association_name, BELONGS_TO)

data/lib/matchers/be_covered_query.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Matchers
+    def be_covered_query
+      BeCoveredQuery.new
+    end
+
+    class BeCoveredQuery
+      PLAN_CHILD_KEYS = %w[inputStage inputStages outerStage innerStage queryPlan winningPlan shards].freeze
+
+      def using_index(name)
+        using_indexes(name)
+      end
+
+      def using_indexes(*names)
+        raise ArgumentError, 'index names must be nonempty strings or symbols' unless names.any? && names.all? { |name| (name.is_a?(String) || name.is_a?(Symbol)) && !name.to_s.empty? }
+
+        @expected_indexes = names.map(&:to_s).uniq.sort
+        self
+      end
+
+      def matches?(actual)
+        @stages = []
+        @indexes = []
+        return false unless actual.respond_to?(:explain)
+
+        explain = actual.explain
+        planner = value_for(explain, :queryPlanner)
+        winning_plan = value_for(planner, :winningPlan)
+        return false unless winning_plan
+
+        collect_plan(winning_plan)
+        covered = @stages.include?('IXSCAN') && (@stages & %w[FETCH COLLSCAN]).empty?
+        covered && (!@expected_indexes || ((@indexes.uniq - @expected_indexes).empty? && (@expected_indexes - @indexes).empty?))
+      end
+
+      def description
+        desc = +'be a covered query'
+        desc << " using indexes #{@expected_indexes.inspect}" if @expected_indexes
+        desc
+      end
+
+      def failure_message
+        detail = @stages.empty? ? 'no winning plan was found' : "winning plan stages were #{@stages.inspect}"
+        detail += " and indexes were #{@indexes.uniq.inspect}" if @expected_indexes && @stages.any?
+        "Expected query to #{description}, but #{detail}"
+      end
+
+      def failure_message_when_negated
+        "Expected query not to #{description}"
+      end
+
+      private
+
+      def value_for(hash, key)
+        return unless hash.respond_to?(:[])
+
+        hash[key.to_s] || hash[key.to_sym]
+      end
+
+      def collect_plan(plan)
+        case plan
+        when Hash
+          stage = value_for(plan, :stage)
+          @stages << stage.to_s if stage
+          @indexes << value_for(plan, :indexName) if stage.to_s == 'IXSCAN'
+          PLAN_CHILD_KEYS.each { |key| collect_plan(value_for(plan, key)) }
+        when Array
+          plan.each { |value| collect_plan(value) }
+        end
+      end
+    end
+  end
+end

data/lib/matchers/be_dynamic_document.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Matchers
     def be_dynamic_document

data/lib/matchers/be_mongoid_document.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Matchers
     def be_mongoid_document

data/lib/matchers/be_stored_in.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Matchers
     def be_stored_in(options)

data/lib/matchers/execute_mongodb_command.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Matchers
+    def execute_mongodb_command(*expected_commands)
+      raise ArgumentError, 'execute_mongodb_command accepts at most one command' if expected_commands.length > 1
+
+      if expected_commands.empty?
+        ExecuteMongodbCommand.new
+      else
+        ExecuteMongodbCommand.new(expected_commands.first)
+      end
+    end
+
+    class ExecuteMongodbCommand
+      DRIVER_METADATA_KEYS = %w[$db lsid $clusterTime].freeze
+      UNSPECIFIED = Object.new.freeze
+
+      def initialize(expected_command = UNSPECIFIED)
+        @expected_command = expected_command.equal?(UNSPECIFIED) ? nil : normalize_command(expected_command)
+      end
+
+      def supports_block_expectations?
+        true
+      end
+
+      def matches?(block)
+        raise ArgumentError, 'execute_mongodb_command expects a block' unless block
+        raise NotImplementedError, 'execute_mongodb_command requires MongoDB driver command monitoring' unless
+          defined?(Mongo::Monitoring::Global) && defined?(Mongo::Monitoring::COMMAND)
+        raise NotImplementedError, 'execute_mongodb_command requires the Mongoid client registry' unless
+          defined?(Mongoid::Clients) && Mongoid::Clients.respond_to?(:clients)
+
+        @command_executed = false
+        topic = Mongo::Monitoring::COMMAND
+        global_monitor = Mongo::Monitoring::Global
+        subscriber = CommandSubscriber.new(Thread.current, @expected_command, method(:normalize_command)) do
+          @command_executed = true
+        end
+        clients = mongoid_clients
+        subscribed = false
+
+        begin
+          clients.each { |client| client.subscribe(topic, subscriber) }
+          global_monitor.subscribe(topic, subscriber)
+          subscribed = true
+          block.call
+        ensure
+          current_clients = mongoid_clients
+          global_monitor.unsubscribe(topic, subscriber) if subscribed
+          (clients + current_clients).uniq.each { |client| client.unsubscribe(topic, subscriber) }
+        end
+
+        @command_executed
+      end
+
+      def failure_message
+        message = +'Expected block to execute a MongoDB command'
+        message << " matching #{@expected_command.inspect}" if @expected_command
+        message
+      end
+
+      def failure_message_when_negated
+        message = +'Expected block not to execute a MongoDB command'
+        message << " matching #{@expected_command.inspect}" if @expected_command
+        message
+      end
+
+      private
+
+      def normalize_command(command)
+        raise ArgumentError, 'expected MongoDB command must be a non-empty Hash' unless command.is_a?(Hash) && !command.empty?
+
+        normalize_document(command, top_level: true)
+      end
+
+      def normalize_document(document, top_level: false)
+        document.each_with_object({}) do |(key, value), normalized|
+          normalized_key = normalize_key(key)
+          next if top_level && DRIVER_METADATA_KEYS.include?(normalized_key)
+          raise ArgumentError, "duplicate MongoDB command key after normalization: #{normalized_key.inspect}" if normalized.key?(normalized_key)
+
+          normalized[normalized_key] = normalize_value(value)
+        end
+      end
+
+      def normalize_key(key)
+        return key if key.is_a?(String)
+        return key.to_s if key.is_a?(Symbol)
+
+        raise ArgumentError, "MongoDB command keys must be Strings or Symbols, got #{key.class}"
+      end
+
+      def normalize_value(value)
+        case value
+        when Hash then normalize_document(value)
+        when Array then value.map { |item| normalize_value(item) }
+        else value
+        end
+      end
+
+      def mongoid_clients
+        Mongoid::Clients.clients.values
+      end
+
+      class CommandSubscriber
+        def initialize(thread, expected_command, normalizer, &on_command)
+          @thread = thread
+          @expected_command = expected_command
+          @normalizer = normalizer
+          @on_command = on_command
+        end
+
+        def started(event)
+          return unless Thread.current.equal?(@thread)
+
+          command = @normalizer.call(event.command)
+          @on_command.call if @expected_command.nil? || command == @expected_command
+        end
+
+        def succeeded(_event); end
+
+        def failed(_event); end
+      end
+    end
+  end
+end

data/lib/matchers/have_field.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Matchers
     class HaveField # :nodoc:
@@ -10,6 +12,11 @@ module Mongoid
         self
       end
 
+      def readonly
+        @readonly = true
+        self
+      end
+
       def of_type(type)
         @type = type
         self
@@ -30,7 +37,7 @@ module Mongoid
         @errors = []
         @attributes.each do |attr|
           if @klass.fields.include?(attr)
-            error = ''
+            error = +''
             if @type && (@klass.fields[attr].type != @type)
               error << " of type #{@klass.fields[attr].type}"
             end
@@ -47,7 +54,11 @@ module Mongoid
               error << " with alias #{@klass.fields[attr].options[:as]}"
             end
 
-            @errors.push("field #{attr.inspect}" << error) unless error.blank?
+            if @readonly && !@klass.readonly_attributes.include?(attr)
+              error << ' that is not readonly'
+            end
+
+            @errors.push("field #{attr.inspect}#{error}") unless error.blank?
 
             if @localized
               unless @klass.fields[attr].localized?
@@ -74,10 +85,11 @@ module Mongoid
       alias failure_message_when_negated failure_message_for_should_not
 
       def description
-        desc = "have #{@attributes.size > 1 ? 'fields' : 'field'} named #{@attributes.collect(&:inspect).to_sentence}"
+        desc = +"have #{@attributes.size > 1 ? 'fields' : 'field'} named #{@attributes.collect(&:inspect).to_sentence}"
         desc << " of type #{@type.inspect}" if @type
         desc << " with alias #{@field_alias}" if @field_alias
         desc << " with default value of #{@default.inspect}" unless @default.nil?
+        desc << ' marked readonly' if @readonly
         desc
       end
     end

data/lib/matchers/have_timestamps.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Matchers
     def have_timestamps
@@ -6,7 +8,7 @@ module Mongoid
 
     class HaveTimestamps
       def initialize
-        @root_module = 'Mongoid::Timestamps'
+        @root_module = +'Mongoid::Timestamps'
       end
 
       def matches?(actual)
@@ -15,7 +17,7 @@ module Mongoid
       end
 
       def for(phase)
-        raise('You\'ve already declared timetamp\'s sub-module via "for" clause') if @submodule
+        raise('You\'ve already declared timestamp\'s sub-module via "for" clause') if @submodule
 
         case @phase = phase.to_sym
         when :creating then @submodule = 'Created'
@@ -33,7 +35,7 @@ module Mongoid
       end
 
       def description
-        desc = 'be a Mongoid document with'
+        desc = +'be a Mongoid document with'
         desc << ' shorted' if @shortened
         desc << " #{@phase}" if @phase
         desc << ' timestamps'

data/lib/matchers/indexes/have_index_for.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Matchers
     class HaveIndexForBase

data/lib/matchers/indexes/v3/have_index_for.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Matchers
     def have_index_for(index_key)
@@ -36,7 +38,7 @@ module Mongoid
       alias failure_message_when_negated failure_message_for_should_not
 
       def description
-        desc = "have an index for #{index_key.inspect}"
+        desc = +"have an index for #{index_key.inspect}"
         desc << " with options of #{index_options.inspect}" if index_options
         desc
       end

data/lib/matchers/indexes/v4/have_index_for.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Matchers
     def have_index_for(index_key)
@@ -15,7 +17,7 @@ module Mongoid
       end
 
       def failure_message
-        message = "Expected #{model.inspect} to #{description},"
+        message = +"Expected #{model.inspect} to #{description},"
         message << if actual_index.nil?
                      ' found no index'
                    else

data/lib/matchers/validations/absence_of.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 if Mongoid::Compatibility::Version.mongoid4_or_newer?
   module Mongoid
     module Matchers

data/lib/matchers/validations/acceptance_of.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Matchers
     module Validations