mongoid-rspec 3.0.0 → 4.0.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

@@ -3,7 +3,6 @@ require 'mongoid/relations'
 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
@@ -28,7 +27,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 +37,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? Mongoid::Criteria::Queryable::Key
             @association[:order_operator] = association_field_name.operator
             @expectation_message << " #{order_way(@association[:order_operator])}"
           end
@@ -49,43 +47,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 +101,7 @@ 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
 
@@ -126,7 +124,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
@@ -250,7 +248,7 @@ module Mongoid
             end
           end
 
-          return true
+          true
         end
 
         def failure_message_for_should
@@ -261,8 +259,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 +269,30 @@ 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
       end
 
       def embed_one(association_name)
@@ -311,12 +310,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 +324,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

data/lib/matchers/have_timestamps.rb

@@ -0,0 +1,61 @@
+module Mongoid
+  module Matchers
+    def have_timestamps
+      HaveTimestamps.new
+    end
+
+    class HaveTimestamps
+      def initialize
+        @root_module = 'Mongoid::Timestamps'
+      end
+
+      def matches?(actual)
+        @model = actual.is_a?(Class) ? actual : actual.class
+        @model.included_modules.include?(expected_module)
+      end
+
+      def for(phase)
+        raise('You\'ve already declared timetamp\'s sub-module via "for" clause') if @submodule
+
+        case @phase = phase.to_sym
+        when :creating then @submodule = 'Created'
+        when :updating then @submodule = 'Updated'
+        else
+          raise('Timestamps can be declared only for creating or updating')
+        end
+
+        self
+      end
+
+      def shortened
+        @shortened = true
+        self
+      end
+
+      def description
+        desc = 'be a Mongoid document with'
+        desc << ' shorted' if @shortened
+        desc << " #{@phase}" if @phase
+        desc << ' timestamps'
+        desc
+      end
+
+      def failure_message
+        "Expected #{@model.inspect} class to #{description}"
+      end
+
+      def failure_message_when_negated
+        "Expected #{@model.inspect} class to not #{description}"
+      end
+
+      private
+
+      def expected_module
+        expected_module = @root_module
+        expected_module << "::#{@submodule}" if @submodule
+        expected_module << '::Short' if @shortened
+        expected_module.constantize
+      end
+    end
+  end
+end