mongoid-rspec-multi-db 1.4.4

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.2-head

data/.travis.yml

@@ -0,0 +1,8 @@
+rvm:
+  - 1.8.7 # (current default)
+  - 1.9.2
+  - rbx
+  - rbx-2.0
+  - ree
+  - jruby
+  - ruby-head

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in mongoid-rspec.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Evan Sagge
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,117 @@
+mongoid-rspec
+=
+
+RSpec matchers for Mongoid.
+
+Association Matchers
+-
+    describe User do
+      it { should reference_many(:articles).with_foreign_key(:author_id) }
+      it { should have_many(:articles).with_foreign_key(:author_id) }
+  
+      it { should reference_one(:record) }
+      it { should have_one(:record) }    
+  
+      it { should reference_many :comments }
+      it { should have_many :comments }
+      
+      #can also specify with_dependent to test if :dependent => :destroy/:destroy_all/:delete is set
+      it { should have_many(:comments).with_dependent(:destroy) }
+      #can verify autosave is set to true
+      it { should have_many(:comments).with_autosave }
+  
+      it { should embed_one :profile }
+  
+      it { should reference_and_be_referenced_in_many(:children).of_type(User) }
+      it { should have_and_belong_to_many(:children) }
+    end
+
+    describe Profile do
+      it { should be_embedded_in(:user).as_inverse_of(:profile) }
+    end
+
+    describe Article do
+      it { should be_referenced_in(:author).of_type(User).as_inverse_of(:articles) }
+      it { should belong_to(:author).of_type(User).as_inverse_of(:articles) }
+      it { should belong_to(:author).of_type(User).as_inverse_of(:articles).with_index }
+      it { should embed_many(:comments) }
+    end
+
+    describe Comment do
+      it { should be_embedded_in(:article).as_inverse_of(:comments) }
+      it { should be_referenced_in(:user).as_inverse_of(:comments) }
+    end
+
+    describe Record do
+      it { should be_referenced_in(:user).as_inverse_of(:record) }
+    end
+
+Validation Matchers
+-
+    describe Site do
+      it { should validate_presence_of(:name) }
+      it { should validate_uniqueness_of(:name) }
+    end
+
+    describe User do
+      it { should validate_presence_of(:login) }
+      it { should validate_uniqueness_of(:login).scoped_to(:site) }
+      it { should validate_uniqueness_of(:email).case_insensitive.with_message("is already taken") }
+      it { should validate_format_of(:login).to_allow("valid_login").not_to_allow("invalid login") }
+      it { should validate_associated(:profile) }
+      it { should validate_inclusion_of(:role).to_allow("admin", "member") }
+      it { should validate_confirmation_of(:email) }
+    end
+
+    describe Article do
+      it { should validate_length_of(:title).within(8..16) }
+    end
+    
+    describe Profile do
+      it { should validate_numericality_of(:age).greater_than(0) }
+    end    
+
+    describe MovieArticle do
+      it { should validate_numericality_of(:rating).to_allow(:greater_than => 0).less_than_or_equal_to(5) }
+      it { should validate_numericality_of(:classification).to_allow(:even => true, :only_integer => true, :nil => false) }    
+    end
+
+Others
+-
+    describe User do
+      it { should have_fields(:email, :login) }
+      it { should have_field(:active).of_type(Boolean).with_default_value_of(false) }
+      it { should have_fields(:birthdate, :registered_at).of_type(DateTime) }
+
+      it { should have_index_for(:last_name) }
+      it { should have_index_for(:email).with_options(:unique => true) }
+
+      # useful if you use factory_girl and have Factory(:user) defined for User
+      it { should save }
+      
+      it { should be_timestamped_document } # if you're declaring `include Mongoid::Timestamps`
+      it { should be_versioned_document } # if you're declaring `include Mongoid::Versioning`
+      it { should be_paranoid_document } # if you're declaring `include Mongoid::Paranoia`
+    end
+    
+    describe Log do
+      it { should be_stored_in :logs }
+    end    
+
+Use
+-
+add in Gemfile
+
+    gem 'mongoid-rspec'
+    
+drop in existing or dedicated support file in spec/support (spec/support/mongoid.rb)
+
+    RSpec.configure do |configuration|
+      configuration.include Mongoid::Matchers
+    end
+    
+Acknowledgement
+-
+Thanks to [Durran Jordan](https://github.com/durran) for providing the changes necessary to make 
+this compatible with mongoid 2.0.0.rc, and for other [contributors](https://github.com/evansagge/mongoid-rspec/contributors) 
+to this project.

data/Rakefile

@@ -0,0 +1,17 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+task :default => :spec
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = "./spec/**/*_spec.rb"
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = "./spec/**/*_spec.rb"
+  spec.rcov = true
+end

data/lib/matchers/associations.rb

@@ -0,0 +1,215 @@
+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
+          # begin
+          #   @association[:class] = name.to_s.classify.constantize
+          # rescue
+          # end
+          @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)
+          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
+        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 stored_as(store_as)
+          raise NotImplementedError, "`references_many #{@association[:name]} :stored_as => :array` has been removed in Mongoid 2.0.0.rc, use `references_and_referenced_in_many #{@association[:name]}` instead"
+        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 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[: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[: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
+
+          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
+
+        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
+      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 :reference_one :have_one_related
+      alias :have_one :have_one_related
+
+      def have_many_related(association_name)
+        HaveAssociationMatcher.new(association_name, HAS_MANY)
+      end
+      alias :reference_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)
+      end
+      alias :reference_and_be_referenced_in_many :have_and_belong_to_many
+
+      def belong_to_related(association_name)
+        HaveAssociationMatcher.new(association_name, BELONGS_TO)
+      end
+      alias :be_referenced_in :belong_to_related
+      alias :belong_to :belong_to_related
+    end
+  end
+end

data/lib/matchers/collections.rb

@@ -0,0 +1,9 @@
+RSpec::Matchers.define :be_stored_in do |collection_name|
+  match do |doc|
+    doc.collection_name == collection_name.to_s
+  end
+
+  description do
+    "be stored in #{collection_name.to_s}"
+  end
+end

data/lib/matchers/document.rb

@@ -0,0 +1,111 @@
+module Mongoid
+  module Matchers
+    class HaveFieldMatcher # :nodoc:
+      def initialize(*attrs)
+        @attributes = attrs.collect(&:to_s)
+      end
+
+      def of_type(type)
+        @type = type
+        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 and @klass.fields[attr].type != @type
+              error << " of type #{@klass.fields[attr].type}"
+            end
+            
+            if !@default.nil? and !@klass.fields[attr].default.nil? and @klass.fields[attr].default != @default
+              error << " with default value of #{@klass.fields[attr].default}"
+            end
+
+            @errors.push("field #{attr.inspect}" << error) unless error.blank?
+          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
+
+      def description
+        desc = "have #{@attributes.size > 1 ? 'fields' : 'field'} named #{@attributes.collect(&:inspect).to_sentence}"
+        desc << " of type #{@type.inspect}" if @type
+        desc << " with default value of #{@default.inspect}" if !@default.nil?
+        desc
+      end
+    end
+
+    def have_field(*args)
+      HaveFieldMatcher.new(*args)
+    end
+    alias_method :have_fields, :have_field
+  end
+end
+
+RSpec::Matchers.define :have_instance_method do |name|
+  match do |klass|
+    klass.instance_methods.include?(name.to_sym)
+  end
+
+  description do
+    "have instance method #{name.to_s}"
+  end
+end
+
+RSpec::Matchers.define :be_mongoid_document do
+  match do |doc|
+    doc.class.included_modules.include?(Mongoid::Document)
+  end
+  
+  description do
+    "be a Mongoid document"
+  end  
+end
+
+RSpec::Matchers.define :be_versioned_document do
+  match do |doc|
+    doc.class.included_modules.include?(Mongoid::Versioning)
+  end
+  
+  description do
+    "be a versioned Mongoid document"
+  end    
+end
+
+RSpec::Matchers.define :be_timestamped_document do
+  match do |doc|
+    doc.class.included_modules.include?(Mongoid::Timestamps)
+  end
+  
+  description do
+    "be a timestamped Mongoid document"
+  end      
+end
+
+RSpec::Matchers.define :be_paranoid_document do
+  match do |doc|
+    doc.class.included_modules.include?(Mongoid::Paranoia)
+  end
+  
+  description do
+    "be a paranoid Mongoid document"
+  end      
+end