mongoid-rspec 2.1.0 → 4.1.0

data/lib/matchers/allow_mass_assignment.rb

@@ -3,7 +3,7 @@ module Mongoid
   module Matchers
     class AllowMassAssignmentOfMatcher # :nodoc:
       attr_reader :failure_message, :negative_failure_message
-      alias :failure_message_when_negated :negative_failure_message
+      alias failure_message_when_negated negative_failure_message
 
       def initialize(attribute)
         @attribute = attribute.to_s
@@ -12,7 +12,7 @@ module Mongoid
 
       def as(role)
         if active_model_less_than_3_1?
-          raise "You can specify role only in Rails 3.1 or greater"
+          raise 'You can specify role only in Rails 3.1 or greater'
         end
         @options[:role] = role
         self
@@ -25,20 +25,20 @@ module Mongoid
             @negative_failure_message = "#{@attribute} was made accessible"
           else
             if protected_attributes.empty?
-              @negative_failure_message = "no attributes were protected"
+              @negative_failure_message = 'no attributes were protected'
             else
-              @negative_failure_message = "#{class_name} is protecting " <<
-                "#{protected_attributes.to_a.to_sentence}, " <<
-                "but not #{@attribute}."
+              @negative_failure_message = "#{class_name} is protecting " \
+                                          "#{protected_attributes.to_a.to_sentence}, " \
+                                          "but not #{@attribute}."
             end
           end
           true
         else
-          if whitelisting?
-            @failure_message = "Expected #{@attribute} to be accessible"
-          else
-            @failure_message = "Did not expect #{@attribute} to be protected"
-          end
+          @failure_message = if whitelisting?
+                               "Expected #{@attribute} to be accessible"
+                             else
+                               "Did not expect #{@attribute} to be protected"
+                             end
           false
         end
       end
@@ -62,7 +62,7 @@ module Mongoid
       end
 
       def whitelisting?
-        authorizer.kind_of?(::ActiveModel::MassAssignmentSecurity::WhiteList)
+        authorizer.is_a?(::ActiveModel::MassAssignmentSecurity::WhiteList)
       end
 
       def attr_mass_assignable?

data/lib/matchers/associations.rb

@@ -1,16 +1,29 @@
-require 'mongoid/relations'
+if Mongoid::Compatibility::Version.mongoid7_or_newer?
+  require 'mongoid/association'
+else
+  require 'mongoid/relations'
+end
 
 module Mongoid
   module Matchers
     module Associations
-
-      HAS_MANY = Mongoid::Relations::Referenced::Many
-      HAS_AND_BELONGS_TO_MANY = Mongoid::Relations::Referenced::ManyToMany
-      HAS_ONE = Mongoid::Relations::Referenced::One
-      BELONGS_TO = Mongoid::Relations::Referenced::In
-      EMBEDS_MANY = Mongoid::Relations::Embedded::Many
-      EMBEDS_ONE = Mongoid::Relations::Embedded::One
-      EMBEDDED_IN = Mongoid::Relations::Embedded::In
+      if Mongoid::Compatibility::Version.mongoid7_or_newer?
+        HAS_MANY = Mongoid::Association::Referenced::HasMany
+        HAS_AND_BELONGS_TO_MANY = Mongoid::Association::Referenced::HasAndBelongsToMany
+        HAS_ONE = Mongoid::Association::Referenced::HasOne
+        BELONGS_TO = Mongoid::Association::Referenced::BelongsTo
+        EMBEDS_MANY = Mongoid::Association::Embedded::EmbedsMany
+        EMBEDS_ONE = Mongoid::Association::Embedded::EmbedsOne
+        EMBEDDED_IN = Mongoid::Association::Embedded::EmbeddedIn
+      else
+        HAS_MANY = Mongoid::Relations::Referenced::Many
+        HAS_AND_BELONGS_TO_MANY = Mongoid::Relations::Referenced::ManyToMany
+        HAS_ONE = Mongoid::Relations::Referenced::One
+        BELONGS_TO = Mongoid::Relations::Referenced::In
+        EMBEDS_MANY = Mongoid::Relations::Embedded::Many
+        EMBEDS_ONE = Mongoid::Relations::Embedded::One
+        EMBEDDED_IN = Mongoid::Relations::Embedded::In
+      end
 
       class HaveAssociationMatcher
         def initialize(name, association_type)
@@ -28,7 +41,6 @@ module Mongoid
         end
 
         def as_inverse_of(association_inverse_name)
-          raise "#{@association[:type].inspect} does not respond to :inverse_of" unless [HAS_MANY, HAS_AND_BELONGS_TO_MANY, BELONGS_TO, EMBEDDED_IN].include?(@association[:type])
           @association[:inverse_of] = association_inverse_name.to_s
           @expectation_message << " which is an inverse of #{@association[:inverse_of].inspect}"
           self
@@ -39,7 +51,7 @@ module Mongoid
           @association[:order] = association_field_name.to_s
           @expectation_message << " ordered by #{@association[:order].inspect}"
 
-          if association_field_name.is_a? Origin::Key
+          if association_field_name.is_a? association_kind_of
             @association[:order_operator] = association_field_name.operator
             @expectation_message << " #{order_way(@association[:order_operator])}"
           end
@@ -49,43 +61,43 @@ module Mongoid
 
         def with_dependent(method_name)
           @association[:dependent] = method_name
-          @expectation_message << " which specifies dependent as #{@association[:dependent].to_s}"
+          @expectation_message << " which specifies dependent as #{@association[:dependent]}"
           self
         end
 
         def with_autosave
           @association[:autosave] = true
-          @expectation_message << " which specifies autosave as #{@association[:autosave].to_s}"
+          @expectation_message << " which specifies autosave as #{@association[:autosave]}"
           self
         end
 
         def with_index
           @association[:index] = true
-          @expectation_message << " which specifies index as #{@association[:index].to_s}"
+          @expectation_message << " which specifies index as #{@association[:index]}"
           self
         end
 
         def with_autobuild
           @association[:autobuild] = true
-          @expectation_message << " which specifies autobuild as #{@association[:autobuild].to_s}"
+          @expectation_message << " which specifies autobuild as #{@association[:autobuild]}"
           self
         end
 
         def with_polymorphism
           @association[:polymorphic] = true
-          @expectation_message << " which specifies polymorphic as #{@association[:polymorphic].to_s}"
+          @expectation_message << " which specifies polymorphic as #{@association[:polymorphic]}"
           self
         end
 
         def with_cascading_callbacks
           @association[:cascade_callbacks] = true
-          @expectation_message << " which specifies cascade_callbacks as #{@association[:cascade_callbacks].to_s}"
+          @expectation_message << " which specifies cascade_callbacks as #{@association[:cascade_callbacks]}"
           self
         end
 
         def cyclic
           @association[:cyclic] = true
-          @expectation_message << " which specifies cyclic as #{@association[:cyclic].to_s}"
+          @expectation_message << " which specifies cyclic as #{@association[:cyclic]}"
           self
         end
 
@@ -103,7 +115,13 @@ module Mongoid
 
         def with_counter_cache
           @association[:counter_cache] = true
-          @expectation_message << " which specifies counter_cache as #{@association[:counter_cache].to_s}"
+          @expectation_message << " which specifies counter_cache as #{@association[:counter_cache]}"
+          self
+        end
+
+        def with_optional
+          @association[:optional] = true
+          @expectation_message << " which specifies optional as #{@association[:optional]}"
           self
         end
 
@@ -118,7 +136,11 @@ module Mongoid
             @positive_result_message = "association named #{@association[:name]}"
           end
 
-          relation = metadata.relation
+          relation = if Mongoid::Compatibility::Version.mongoid7_or_newer?
+                       metadata.class
+                     else
+                       metadata.relation
+                     end
           if relation != @association[:type]
             @negative_result_message = "#{@actual.inspect} #{type_description(relation, false)} #{@association[:name]}"
             return false
@@ -126,7 +148,7 @@ module Mongoid
             @positive_result_message = "#{@actual.inspect} #{type_description(relation, false)} #{@association[:name]}"
           end
 
-          if !@association[:class].nil? and @association[:class] != metadata.klass
+          if !@association[:class].nil? && (@association[:class] != metadata.klass)
             @negative_result_message = "#{@positive_result_message} of type #{metadata.klass.inspect}"
             return false
           else
@@ -224,11 +246,11 @@ module Mongoid
           end
 
           if @association[:index]
-            if metadata.index != true
+            if metadata.indexed?
+              @positive_result_message = "#{@positive_result_message} which set index"
+            else
               @negative_result_message = "#{@positive_result_message} which did not set index"
               return false
-            else
-              @positive_result_message = "#{@positive_result_message} which set index"
             end
           end
 
@@ -250,7 +272,16 @@ module Mongoid
             end
           end
 
-          return true
+          if @association[:optional]
+            if metadata.options[:optional] != true
+              @negative_result_message = "#{@positive_result_message} which did not set optional"
+              return false
+            else
+              @positive_result_message = "#{@positive_result_message} which set optional"
+            end
+          end
+
+          true
         end
 
         def failure_message_for_should
@@ -261,8 +292,8 @@ module Mongoid
           "Expected #{@actual.inspect} to not #{@expectation_message}, got #{@positive_result_message}"
         end
 
-        alias :failure_message :failure_message_for_should
-        alias :failure_message_when_negated :failure_message_for_should_not
+        alias failure_message failure_message_for_should
+        alias failure_message_when_negated failure_message_for_should_not
 
         def description
           @expectation_message
@@ -271,29 +302,34 @@ module Mongoid
         def type_description(type = nil, passive = true)
           type ||= @association[:type]
           case type.name
-            when EMBEDS_ONE.name
-              (passive ? 'embed' : 'embeds') << ' one'
-            when EMBEDS_MANY.name
-              (passive ? 'embed' : 'embeds') << ' many'
-            when EMBEDDED_IN.name
-              (passive ? 'be' : 'is') << ' embedded in'
-            when HAS_ONE.name
-              (passive ? 'reference' : 'references') << ' one'
-            when HAS_MANY.name
-              (passive ? 'reference' : 'references') << ' many'
-            when HAS_AND_BELONGS_TO_MANY.name
-              (passive ? 'reference' : 'references') << ' and referenced in many'
-            when BELONGS_TO.name
-              (passive ? 'be referenced in' : 'referenced in')
-            else
-              raise "Unknown association type '%s'" % type
+          when EMBEDS_ONE.name
+            (passive ? 'embed' : 'embeds') << ' one'
+          when EMBEDS_MANY.name
+            (passive ? 'embed' : 'embeds') << ' many'
+          when EMBEDDED_IN.name
+            (passive ? 'be' : 'is') << ' embedded in'
+          when HAS_ONE.name
+            (passive ? 'reference' : 'references') << ' one'
+          when HAS_MANY.name
+            (passive ? 'reference' : 'references') << ' many'
+          when HAS_AND_BELONGS_TO_MANY.name
+            (passive ? 'reference' : 'references') << ' and referenced in many'
+          when BELONGS_TO.name
+            (passive ? 'be referenced in' : 'referenced in')
+          else
+            raise format("Unknown association type '%s'", type)
           end
         end
 
         private
-          def order_way(operator)
-            [nil, "ascending", "descending"][operator]
-          end
+
+        def order_way(operator)
+          [nil, 'ascending', 'descending'][operator]
+        end
+
+        def association_kind_of
+          Mongoid::Compatibility::Version.mongoid5_or_older? ? Origin::Key : Mongoid::Criteria::Queryable::Key
+        end
       end
 
       def embed_one(association_name)
@@ -311,12 +347,12 @@ module Mongoid
       def have_one_related(association_name)
         HaveAssociationMatcher.new(association_name, HAS_ONE)
       end
-      alias :have_one :have_one_related
+      alias have_one have_one_related
 
       def have_many_related(association_name)
         HaveAssociationMatcher.new(association_name, HAS_MANY)
       end
-      alias :have_many :have_many_related
+      alias have_many have_many_related
 
       def have_and_belong_to_many(association_name)
         HaveAssociationMatcher.new(association_name, HAS_AND_BELONGS_TO_MANY)
@@ -325,7 +361,7 @@ module Mongoid
       def belong_to_related(association_name)
         HaveAssociationMatcher.new(association_name, BELONGS_TO)
       end
-      alias :belong_to :belong_to_related
+      alias belong_to belong_to_related
     end
   end
 end

data/lib/matchers/be_dynamic_document.rb

@@ -0,0 +1,26 @@
+module Mongoid
+  module Matchers
+    def be_dynamic_document
+      BeDynamicDocument.new
+    end
+
+    class BeDynamicDocument
+      def matches?(actual)
+        @model = actual.is_a?(Class) ? actual : actual.class
+        @model.included_modules.include?(Mongoid::Attributes::Dynamic)
+      end
+
+      def description
+        'include Mongoid::Attributes::Dynamic'
+      end
+
+      def failure_message
+        "expect #{@model.inspect} class to #{description}"
+      end
+
+      def failure_message_when_negated
+        "expect #{@model.inspect} class to not #{description}"
+      end
+    end
+  end
+end

data/lib/matchers/be_mongoid_document.rb

@@ -0,0 +1,26 @@
+module Mongoid
+  module Matchers
+    def be_mongoid_document
+      BeMongoidDocument.new
+    end
+
+    class BeMongoidDocument
+      def matches?(actual)
+        @model = actual.is_a?(Class) ? actual : actual.class
+        @model.included_modules.include?(Mongoid::Document)
+      end
+
+      def description
+        'include Mongoid::Document'
+      end
+
+      def failure_message
+        "expect #{@model.inspect} class to #{description}"
+      end
+
+      def failure_message_when_negated
+        "expect #{@model.inspect} class to not #{description}"
+      end
+    end
+  end
+end

data/lib/matchers/be_stored_in.rb

@@ -0,0 +1,55 @@
+module Mongoid
+  module Matchers
+    def be_stored_in(options)
+      BeStoredIn.new(options)
+    end
+
+    class BeStoredIn
+      def initialize(expected)
+        @expected_options = expected.transform_values { |v| v.to_sym rescue v }.symbolize_keys
+      end
+
+      def matches?(actual)
+        @model = actual.is_a?(Class) ? actual : actual.class
+        actual_options == @expected_options
+      end
+
+      def description
+        "be stored in #{@expected_options.inspect}"
+      end
+
+      def failure_message
+        "Expected #{@model.inspect} to #{description}, got #{actual_options.inspect}"
+      end
+
+      def failure_message_when_negated
+        "Expected #{@model.inspect} not to #{description}, got #{actual_options.inspect}"
+      end
+
+      private
+
+      def actual_options
+        @actual_options ||= begin
+          hash = @model.storage_options.slice(*@expected_options.keys)
+          hash.each do |option, value|
+            hash[option] =
+              if value.is_a?(Proc)
+                evaluated_value = @model.persistence_context.send("#{option}_name")
+                begin
+                  evaluated_value.to_sym
+                rescue StandardError
+                  evaluated_value
+                end
+              else
+                begin
+                  value.to_sym
+                rescue StandardError
+                  value
+                end
+              end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/matchers/have_field.rb

@@ -0,0 +1,90 @@
+module Mongoid
+  module Matchers
+    class HaveField # :nodoc:
+      def initialize(*attrs)
+        @attributes = attrs.collect(&:to_s)
+      end
+
+      def localized
+        @localized = true
+        self
+      end
+
+      def of_type(type)
+        @type = type
+        self
+      end
+
+      def with_alias(field_alias)
+        @field_alias = field_alias
+        self
+      end
+
+      def with_default_value_of(default)
+        @default = default
+        self
+      end
+
+      def matches?(klass)
+        @klass = klass.is_a?(Class) ? klass : klass.class
+        @errors = []
+        @attributes.each do |attr|
+          if @klass.fields.include?(attr)
+            error = ''
+            if @type && (@klass.fields[attr].type != @type)
+              error << " of type #{@klass.fields[attr].type}"
+            end
+
+            unless @default.nil?
+              if @klass.fields[attr].default_val.nil?
+                error << ' with default not set'
+              elsif @klass.fields[attr].default_val != @default
+                error << " with default value of #{@klass.fields[attr].default_val}"
+              end
+            end
+
+            if @field_alias && (@klass.fields[attr].options[:as] != @field_alias)
+              error << " with alias #{@klass.fields[attr].options[:as]}"
+            end
+
+            @errors.push("field #{attr.inspect}" << error) unless error.blank?
+
+            if @localized
+              unless @klass.fields[attr].localized?
+                @errors.push "is not localized #{attr.inspect}"
+              end
+            end
+
+          else
+            @errors.push "no field named #{attr.inspect}"
+          end
+        end
+        @errors.empty?
+      end
+
+      def failure_message_for_should
+        "Expected #{@klass.inspect} to #{description}, got #{@errors.to_sentence}"
+      end
+
+      def failure_message_for_should_not
+        "Expected #{@klass.inspect} to not #{description}, got #{@klass.inspect} to #{description}"
+      end
+
+      alias failure_message failure_message_for_should
+      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 << " 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
+      end
+    end
+
+    def have_field(*args)
+      HaveField.new(*args)
+    end
+    alias have_fields have_field
+  end
+end