mongoid-spec 4.0.1

data/lib/matchers/allow_mass_assignment.rb

@@ -0,0 +1,102 @@
+# this code is totally extracted from shoulda-matchers gem.
+module Mongoid
+  module Matchers
+    class AllowMassAssignmentOfMatcher # :nodoc:
+      attr_reader :failure_message, :negative_failure_message
+      alias :failure_message_when_negated :negative_failure_message
+
+      def initialize(attribute)
+        @attribute = attribute.to_s
+        @options = {}
+      end
+
+      def as(role)
+        if active_model_less_than_3_1?
+          raise "You can specify role only in Rails 3.1 or greater"
+        end
+        @options[:role] = role
+        self
+      end
+
+      def matches?(klass)
+        @klass = klass
+        if attr_mass_assignable?
+          if whitelisting?
+            @negative_failure_message = "#{@attribute} was made accessible"
+          else
+            if protected_attributes.empty?
+              @negative_failure_message = "no attributes were protected"
+            else
+              @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
+          false
+        end
+      end
+
+      def description
+        "allow mass assignment of #{@attribute}"
+      end
+
+      private
+
+      def role
+        @options[:role] || :default
+      end
+
+      def protected_attributes
+        @protected_attributes ||= (@klass.class.protected_attributes || [])
+      end
+
+      def accessible_attributes
+        @accessible_attributes ||= (@klass.class.accessible_attributes || [])
+      end
+
+      def whitelisting?
+        authorizer.kind_of?(::ActiveModel::MassAssignmentSecurity::WhiteList)
+      end
+
+      def attr_mass_assignable?
+        !authorizer.deny?(@attribute)
+      end
+
+      def authorizer
+        if active_model_less_than_3_1?
+          @klass.class.active_authorizer
+        else
+          @klass.class.active_authorizer[role]
+        end
+      end
+
+      def class_name
+        @klass.class.name
+      end
+
+      def active_model_less_than_3_1?
+        ::ActiveModel::VERSION::STRING.to_f < 3.1
+      end
+    end
+
+    # Ensures that the attribute can be set on mass update.
+    #
+    #   it { should_not allow_mass_assignment_of(:password) }
+    #   it { should allow_mass_assignment_of(:first_name) }
+    #
+    # In Rails 3.1 you can check role as well:
+    #
+    #   it { should allow_mass_assignment_of(:first_name).as(:admin) }
+    #
+    def allow_mass_assignment_of(value)
+      AllowMassAssignmentOfMatcher.new(value)
+    end
+  end
+end

data/lib/matchers/associations.rb

@@ -0,0 +1,330 @@
+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
+      BELONGS_TO = Mongoid::Relations::Referenced::In
+      EMBEDS_MANY = Mongoid::Relations::Embedded::Many
+      EMBEDS_ONE = Mongoid::Relations::Embedded::One
+      EMBEDDED_IN = Mongoid::Relations::Embedded::In
+
+      class HaveAssociationMatcher
+        def initialize(name, association_type)
+          @association = {}
+          @association[:name] = name.to_s
+          @association[:type] = association_type
+          @expectation_message = "#{type_description} #{@association[:name].inspect}"
+          @expectation_message << " of type #{@association[:class].inspect}" unless @association[:class].nil?
+        end
+
+        def of_type(klass)
+          @association[:class] = klass
+          @expectation_message << " of type #{@association[:class].inspect}"
+          self
+        end
+
+        def as_inverse_of(association_inverse_name)
+          @association[:inverse_of] = association_inverse_name.to_s
+          @expectation_message << " which is an inverse of #{@association[:inverse_of].inspect}"
+          self
+        end
+
+        def ordered_by(association_field_name)
+          raise "#{@association[:type].inspect} does not respond to :order" unless [HAS_MANY, HAS_AND_BELONGS_TO_MANY, EMBEDS_MANY].include?(@association[:type])
+          @association[:order] = association_field_name.to_s
+          @expectation_message << " ordered by #{@association[:order].inspect}"
+
+          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
+
+          self
+        end
+
+        def with_dependent(method_name)
+          @association[:dependent] = method_name
+          @expectation_message << " which specifies dependent as #{@association[:dependent].to_s}"
+          self
+        end
+
+        def with_autosave
+          @association[:autosave] = true
+          @expectation_message << " which specifies autosave as #{@association[:autosave].to_s}"
+          self
+        end
+
+        def with_index
+          @association[:index] = true
+          @expectation_message << " which specifies index as #{@association[:index].to_s}"
+          self
+        end
+
+        def with_autobuild
+          @association[:autobuild] = true
+          @expectation_message << " which specifies autobuild as #{@association[:autobuild].to_s}"
+          self
+        end
+
+        def with_polymorphism
+          @association[:polymorphic] = true
+          @expectation_message << " which specifies polymorphic as #{@association[:polymorphic].to_s}"
+          self
+        end
+
+        def with_cascading_callbacks
+          @association[:cascade_callbacks] = true
+          @expectation_message << " which specifies cascade_callbacks as #{@association[:cascade_callbacks].to_s}"
+          self
+        end
+
+        def cyclic
+          @association[:cyclic] = true
+          @expectation_message << " which specifies cyclic as #{@association[:cyclic].to_s}"
+          self
+        end
+
+        def stored_as(store_as)
+          @association[:store_as] = store_as.to_s
+          @expectation_message << " which is stored as #{@association[:store_as].inspect}"
+          self
+        end
+
+        def with_foreign_key(foreign_key)
+          @association[:foreign_key] = foreign_key.to_s
+          @expectation_message << " using foreign key #{@association[:foreign_key].inspect}"
+          self
+        end
+
+        def with_counter_cache
+          @association[:counter_cache] = true
+          @expectation_message << " which specifies counter_cache as #{@association[:counter_cache].to_s}"
+          self
+        end
+
+        def matches?(actual)
+          @actual = actual.is_a?(Class) ? actual : actual.class
+          metadata = @actual.relations[@association[:name]]
+
+          if metadata.nil?
+            @negative_result_message = "no association named #{@association[:name]}"
+            return false
+          else
+            @positive_result_message = "association named #{@association[:name]}"
+          end
+
+          relation = metadata.relation
+          if relation != @association[:type]
+            @negative_result_message = "#{@actual.inspect} #{type_description(relation, false)} #{@association[:name]}"
+            return false
+          else
+            @positive_result_message = "#{@actual.inspect} #{type_description(relation, false)} #{@association[:name]}"
+          end
+
+          if !@association[:class].nil? and @association[:class] != metadata.klass
+            @negative_result_message = "#{@positive_result_message} of type #{metadata.klass.inspect}"
+            return false
+          else
+            @positive_result_message = "#{@positive_result_message}#{" of type #{metadata.klass.inspect}" if @association[:class]}"
+          end
+
+          if @association[:inverse_of]
+            if @association[:inverse_of].to_s != metadata.inverse_of.to_s
+              @negative_result_message = "#{@positive_result_message} which is an inverse of #{metadata.inverse_of}"
+              return false
+            else
+              @positive_result_message = "#{@positive_result_message} which is an inverse of #{metadata.inverse_of}"
+            end
+          end
+
+          if @association[:order]
+            if @association[:order].to_s != metadata.order.to_s
+              @negative_result_message = "#{@positive_result_message} ordered by #{metadata.order}"
+              return false
+            else
+              @positive_result_message = "#{@positive_result_message} ordered by #{metadata.order}"
+            end
+          end
+
+          if @association[:order_operator]
+            if @association[:order_operator] != metadata.order.operator
+              @negative_result_message = "#{@positive_result_message} #{order_way(@association[:order_operator] * -1)}"
+              return false
+            else
+              @positive_result_message = "#{@positive_result_message} #{order_way(@association[:order_operator])}"
+            end
+          end
+
+          if @association[:dependent]
+            if @association[:dependent].to_s != metadata.dependent.to_s
+              @negative_result_message = "#{@positive_result_message} which specified dependent as #{metadata.dependent}"
+              return false
+            else
+              @positive_result_message = "#{@positive_result_message} which specified dependent as #{metadata.dependent}"
+            end
+          end
+
+          if @association[:autosave]
+            if metadata.autosave != true
+              @negative_result_message = "#{@positive_result_message} which did not set autosave"
+              return false
+            else
+              @positive_result_message = "#{@positive_result_message} which set autosave"
+            end
+          end
+
+          if @association[:autobuild]
+            if metadata.autobuilding? != true
+              @negative_result_message = "#{@positive_result_message} which did not set autobuild"
+              return false
+            else
+              @positive_result_message = "#{@positive_result_message} which set autobuild"
+            end
+          end
+
+          if @association[:polymorphic]
+            if metadata.polymorphic? != true
+              @negative_result_message = "#{@positive_result_message} which did not set polymorphic"
+              return false
+            else
+              @positive_result_message = "#{@positive_result_message} which set polymorphic"
+            end
+          end
+
+          if @association[:cascade_callbacks]
+            if metadata.cascading_callbacks? != true
+              @negative_result_message = "#{@positive_result_message} which did not set cascade_callbacks"
+              return false
+            else
+              @positive_result_message = "#{@positive_result_message} which set cascade_callbacks"
+            end
+          end
+
+          if @association[:cyclic]
+            if metadata.cyclic? != true
+              @negative_result_message = "#{@positive_result_message} which did not set cyclic"
+              return false
+            else
+              @positive_result_message = "#{@positive_result_message} which set cyclic"
+            end
+          end
+
+          if @association[:store_as]
+            if metadata.store_as != @association[:store_as]
+              @negative_result_message = "#{@positive_result_message} which is stored as #{metadata.store_as}"
+              return false
+            else
+              @positive_result_message = "#{@positive_result_message} which is stored as #{metadata.store_as}"
+            end
+          end
+
+          if @association[:index]
+            if metadata.index != true
+              @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
+
+          if @association[:foreign_key]
+            if metadata.foreign_key != @association[:foreign_key]
+              @negative_result_message = "#{@positive_result_message} with foreign key #{metadata.foreign_key.inspect}"
+              return false
+            else
+              @positive_result_message = "#{@positive_result_message} with foreign key #{metadata.foreign_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"
+              return false
+            else
+              @positive_result_message = "#{@positive_result_message} which set counter_cache"
+            end
+          end
+
+          return true
+        end
+
+        def failure_message_for_should
+          "Expected #{@actual.inspect} to #{@expectation_message}, got #{@negative_result_message}"
+        end
+
+        def failure_message_for_should_not
+          "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
+
+        def description
+          @expectation_message
+        end
+
+        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
+          end
+        end
+
+        private
+          def order_way(operator)
+            [nil, "ascending", "descending"][operator]
+          end
+      end
+
+      def embed_one(association_name)
+        HaveAssociationMatcher.new(association_name, EMBEDS_ONE)
+      end
+
+      def embed_many(association_name)
+        HaveAssociationMatcher.new(association_name, EMBEDS_MANY)
+      end
+
+      def be_embedded_in(association_name)
+        HaveAssociationMatcher.new(association_name, EMBEDDED_IN)
+      end
+
+      def have_one_related(association_name)
+        HaveAssociationMatcher.new(association_name, HAS_ONE)
+      end
+      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
+
+      def have_and_belong_to_many(association_name)
+        HaveAssociationMatcher.new(association_name, HAS_AND_BELONGS_TO_MANY)
+      end
+
+      def belong_to_related(association_name)
+        HaveAssociationMatcher.new(association_name, BELONGS_TO)
+      end
+      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