mongoid-minitest 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.DS_Store

data/.rbenv-version

@@ -0,0 +1 @@
+1.9.3-p125

data/CHANGELOG.md

@@ -0,0 +1,30 @@
+### 0.0.1
+
++ Added `of_type` matcher to `HaveAssociationMatcher`.
++ Added `have_many` association matcher.
++ Added `Mongoid::Matchers::Associations` module.
++ Added `to_not_allow` matcher to `ValidateExclusionMatcher`.
++ Added `validate_exclusion_of` matcher.
++ Added `to_not_allow` matcher to `ValidateFormatMatcher`.
++ Added `to_allow` matcher to `ValidateFormatMatcher`.
++ Added `validate_format_of` matcher.
++ Added `with_max` alias to `with_maximum` matcher.
++ Added `with_maximum` matcher to `ValidateLengthMatcher`
++ Added `with_min` alias to `with_minimum` matcher.
++ Added `with_minimum` matcher to `ValidateLengthMatcher`.
++ Added `validate_length_of` matcher.
++ Added `case_sensitive` matcher to `ValidateUniquenessMatcher`.
++ Added `validate_uniqueness_of` matcher.
++ Added `validate_presence_of` matcher.
++ Added `have_fields` matcher.
++ Added `be_timestamped` document matcher.
++ Added `be_versioned` document matcher.
++ Added `be_paranoid` document matcher.
++ Added default failure messages based on description matcher.
++ Added `be_document` document matcher.
++ Added `with_default_value` matcher to `HaveFieldMatcher`.
++ Added `of_type` matcher to `HaveFieldMatcher`.
++ Added `must` and `wont` methods to `MiniTest::Spec`.
++ Added `have_field` matcher.
++ Added `must` and `wont` expectations.
++ Added `assert_must` and `assert_wont` to `MiniTest::Assertions`.

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,7 @@
+guard 'minitest' do
+  watch(%r|^test/(.*)_test\.rb|)
+  watch(%r|^test/test_helper\.rb|) { "test" }
+  watch(%r|^test/models/(.*)\.rb|) { "test" }
+  watch(%r|^lib/mongoid-minitest\.rb|) { "test" }
+  watch(%r|^lib/matchers/(.*)\.rb|) { "test" }
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Francesco Rodriguez
+
+MIT License
+
+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,166 @@
+# mongoid-minitest
+
+MiniTest matchers for Mongoid.  
+
+Requires Ruby 1.9.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'mongoid-minitest'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mongoid-minitest
+
+## Usage
+
+Matchers are available at `Mongoid::Matchers` module.  
+Setup matchers according to your testing preference:
+
+### minitest/unit
+
+    class MiniTest::Unit::TestCase
+      include Mongoid::Matchers
+    end
+
+### minitest/spec
+
+    class MiniTest::Spec
+      include Mongoid::Matchers
+    end
+
+See the following examples:
+
+    # minitest/unit
+    class DummyTest < MiniTest::Unit::TestCase
+      def test_matchers
+        assert_must Dummy, have_field(:name)
+        assert_wont Dummy, have_field(:none)
+      end
+    end
+
+    # minitest/spec
+    describe Dummy
+      it "sould test matchers" do
+        Dummy.must have_field(:name)
+        Dummy.wont have_field(:none)
+      end
+    end
+
+    # minitest/spec with subject
+    describe Dummy
+      it { must have_field(:name) }
+      it { wont have_field(:none) }
+    end
+
+## Matchers
+
+`Mongoid::Matchers` include the following modules:
+
+    Module Mongoid
+      Module Matchers
+        include Mongoid::Matchers::Document
+        include Mongoid::Matchers::Validations
+        include Mongoid::Matchers::Associations
+      end
+    end
+
+### Document Matchers
+
+    describe Mongoid::Matchers::Document do
+      subject { Person }
+
+      it { must be_document }
+      it { must be_paranoid }
+      it { must be_versioned }
+      it { must be_timestamped }
+
+      it { must have_field(:name) }
+      it { must have_field(:name).of_type(String) }
+      it { must have_field(:name).with_default_value("me") }
+      it { must have_field(:name).of_type(String).with_default_value("me") }
+
+      it { must have_fields(:name, :login) }
+      it { must have_fields(:name, :login).of_type(String) }
+      it { must have_fields(:name, :login).with_default_value("me") }
+      it { must have_fields(:name, :login).of_type(String).with_default_value("me") }
+    end
+
+### Validations Matchers
+
+    describe Mongoid::Matchers::Validations do
+      subject { Person }
+
+      it { must validate_presence_of(:name) }
+
+      it { must validate_uniqueness_of(:login).case_insensitive }
+
+      it { must validate_length_of(:password).with_min(8) }
+      it { must validate_length_of(:password).with_minimum(8) }
+      it { must validate_length_of(:password).with_max(16) }
+      it { must validate_length_of(:password).with_maximum(16) }
+
+      it { must validate_format_of(:email).to_allow("foo@bar.com") }
+      it { must validate_format_of(:email).to_not_allow("foo_bar_com") }
+
+      it { must validate_exclusion_of(:email).to_not_allow("foo@bar.com", "fizz@buzz.com") }
+    end
+
+### Association Matchers
+
+    describe Mongoid::Matchers::Associations do
+      subject { Person }
+
+      it { must have_many(:pets).of_type(Pet) }
+    end
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Unit Tests
+
+To run unit tests, run `bundle exec rake` or `bundle exec guard` to run in auto mode.
+
+## License
+
+Copyright (c) 2012 Francesco Rodriguez
+
+MIT License
+
+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.
+
+## Last words
+
+At [EpicLabs](https://github.com/epiclabs/), We're migrating all the tests from `rspec` to `minitest`. I've been using
+[mongoid-rspec gem](https://github.com/evansagge/mongoid-rspec) by [evanssage](https://github.com/evansagge).
+So, this gem is heavily inspired in Evan's gem and [minitest-matchers](https://github.com/zenspider/minitest-matchers) gem
+by [zenspider](https://github.com/zenspider). We love [minitest](https://github.com/seattlerb/minitest) and
+we hope that this will be helpful for you. Thanks!

data/Rakefile

@@ -0,0 +1,11 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.pattern = "test/*/*_test.rb"
+end
+
+task :default => [:test]

data/lib/matchers/associations/associations.rb

@@ -0,0 +1,98 @@
+module Mongoid
+  module Matchers
+    module Associations
+      HAS_MANY = Mongoid::Relations::Referenced::Many
+
+      class HaveAssociationMatcher
+        def initialize(name, type)
+          @association = {}
+          @association[:name] = name.to_s
+          @association[:type] = type
+          @expectation_message = "#{type_description} #{@association[:name].inspect}"
+        end
+
+        def of_type(klass)
+          @association[:class] = klass
+          @expectation_message << " of type #{@association[:class].inspect}"
+          self
+        end
+
+        def matches?(klass)
+          @klass    = klass.is_a?(Class) ? klass : klass.class
+          @metadata = @klass.relations[@association[:name]] 
+          @result   = true
+
+          check_association_name
+          check_association_type  if @result
+          check_association_class if @result
+
+          @result
+        end
+
+        def failure_message
+          "Expected #{@klass} to #{@expectation_message}, got #{@negative_message}"
+        end
+
+        def negative_failure_message
+          "Expected #{@klass} to not #{@expectation_message}, got #{@positive_message}"
+        end
+
+        def description
+          @expectation_message
+        end
+
+        private
+
+        def check_association_name
+          if @metadata.nil?
+            @negative_message = "no association named #{@association[:name]}"
+            @result = false
+          else
+            @positive_message = "association named #{@association[:name]}"
+          end
+        end
+
+        def check_association_type
+          @relation = @metadata.relation
+          if @relation != @association[:type]
+            @negative_message = association_type_failure_message
+            @result = false
+          else
+            @positive_message = association_type_failure_message
+          end
+        end
+
+        def association_type_failure_message
+          msg = "#{@klass.inspect}"
+          msg << " #{type_description(@relation, false)}"
+          msg << " #{@association[:name].inspect}"
+
+          msg
+        end
+
+        def check_association_class
+          if !@association[:class].nil? and @association[:class] != @metadata.klass
+            @negative_message = "#{@positive_message} of type #{@metadata.klass}"
+            @result = false
+          else
+            @positive_message << " of type #{@metadata.klass}" if @association[:class]
+          end
+        end
+
+        def type_description(type = nil, passive = true)
+          type ||= @association[:type]
+          case type.name
+          when HAS_MANY.name
+            (passive ? "reference" : "references") << " many"
+          else
+            raise "Unknown association type '%s'" % type
+          end
+        end
+      end
+
+      def have_many(association_name)
+        HaveAssociationMatcher.new(association_name, HAS_MANY)
+      end
+    end
+  end
+end

data/lib/matchers/document/be_document.rb

@@ -0,0 +1,20 @@
+module Mongoid
+  module Matchers
+    module Document
+      class BeDocumentMatcher
+        def matches?(klass)
+          @klass = klass
+          @klass.included_modules.include?(Mongoid::Document)
+        end
+
+        def description
+          "be a Mongoid document"
+        end
+      end
+
+      def be_document
+        BeDocumentMatcher.new
+      end
+    end
+  end
+end

data/lib/matchers/document/be_paranoid.rb

@@ -0,0 +1,20 @@
+module Mongoid
+  module Matchers
+    module Document
+      class BeParanoidMatcher
+        def matches?(klass)
+          @klass = klass
+          @klass.included_modules.include?(Mongoid::Paranoia)
+        end
+
+        def description
+          "be a paranoid Mongoid document"
+        end
+      end
+
+      def be_paranoid
+        BeParanoidMatcher.new
+      end
+    end
+  end
+end

data/lib/matchers/document/be_timestamped.rb

@@ -0,0 +1,20 @@
+module Mongoid
+  module Matchers
+    module Document
+      class BeTimestamped
+        def matches?(klass)
+          @klass = klass
+          @klass.included_modules.include?(Mongoid::Timestamps)
+        end
+
+        def description
+          "be timestamped Mongoid document"
+        end
+      end
+
+      def be_timestamped
+        BeTimestamped.new
+      end
+    end
+  end
+end

data/lib/matchers/document/be_versioned.rb

@@ -0,0 +1,20 @@
+module Mongoid
+  module Matchers
+    module Document
+      class BeVersionedMatcher
+        def matches?(klass)
+          @klass = klass
+          @klass.included_modules.include?(Mongoid::Versioning)
+        end
+
+        def description
+          "be a versioned Mongoid document"
+        end
+      end
+
+      def be_versioned
+        BeVersionedMatcher.new
+      end
+    end
+  end
+end

data/lib/matchers/document/have_field.rb

@@ -0,0 +1,72 @@
+module Mongoid
+  module Matchers
+    module Document
+      class HaveFieldMatcher
+        include Mongoid::Matchers::Helpers
+
+        def initialize(*fields)
+          @fields = fields.collect(&:to_s)
+        end
+
+        def of_type(type)
+          @type = type
+          self
+        end
+
+        def with_default_value(default)
+          @default = default
+          self
+        end
+
+        def matches?(klass)
+          @klass  = klass.is_a?(Class) ? klass : klass.class
+          @errors = []
+
+          @fields.each do |field|
+            if @klass.fields.include?(field)
+              error = ""
+              result_field = @klass.fields[field]
+              
+              if @type && result_field.type != @type
+                error << " of type #{result_field.type.inspect}"
+              end
+
+              if !@default.nil? && !result_field.default.nil? && result_field.default != @default
+                error << " with default value of #{result_field.default.inspect}"
+              end
+
+              @errors << "field #{field.inspect << error}" if !error.blank?
+            else
+              @errors << "no field named #{field.inspect}"
+            end
+          end
+
+          @errors.empty?
+        end
+
+        def failure_message
+          "Expected #{@klass.inspect} to #{description}, got #{@errors.to_sentence}"
+        end
+
+        def negative_failure_message
+          msg =  "Expected #{@klass.inspect} to not #{description}, "
+          msg << "got #{@klass.inspect} to #{description}"
+        end
+
+        def description
+          desc =  "have #{@fields.size > 1 ? 'fields' : 'field'} named"
+          desc << " #{to_sentence(@fields)}"
+          desc << " of type #{@type.inspect}" if @type
+          desc << " with default value of #{@default.inspect}" if !@default.nil?
+          desc
+        end
+      end
+
+      def have_field(*fields)
+        HaveFieldMatcher.new(*fields)
+      end
+      alias :have_fields :have_field
+
+    end
+  end
+end

data/lib/matchers/helpers.rb

@@ -0,0 +1,9 @@
+module Mongoid
+  module Matchers
+    module Helpers
+      def to_sentence(ary)
+        ary.collect(&:inspect).to_sentence
+      end
+    end
+  end
+end

data/lib/matchers/validations/exclusion_of.rb

@@ -0,0 +1,43 @@
+module Mongoid
+  module Matchers
+    module Validations
+      class ValidateExclusionMatcher < HaveValidationMatcher
+        def initialize(field)
+          super(field, :exclusion)
+        end
+
+        def to_not_allow(*values)
+          @not_allowed_values = values.flatten
+          self
+        end
+
+        def matches?(actual)
+          return false unless result = super(actual)
+
+          if @not_allowed_values
+            allowed_values = @not_allowed_values - @validator.options[:in]
+            if allowed_values.empty?
+              @positive_message << " not allowing all values mentioned"
+            else
+              @negative_message << " allowing the values:"
+              @negative_message << " #{to_sentence(allowed_values)}"
+              result = false
+            end
+          end
+
+          result
+        end
+
+        def description
+          if @not_allowed_values
+            super << " not allowing the values: #{to_sentence(@not_allowed_values)}"
+          end
+        end
+      end
+
+      def validate_exclusion_of(field)
+        ValidateExclusionMatcher.new(field)
+      end
+    end
+  end
+end

data/lib/matchers/validations/format_of.rb

@@ -0,0 +1,65 @@
+module Mongoid
+  module Matchers
+    module Validations
+      class ValidateFormatMatcher < HaveValidationMatcher
+        def initialize(field)
+          super(field, :format)
+        end
+
+        def to_allow(valid_value)
+          @valid = valid_value
+          self
+        end
+
+        def to_not_allow(invalid_value)
+          @invalid = invalid_value
+          self
+        end
+
+        def matches?(klass)
+          return false unless @result = super(klass)
+
+          check_valid_value   if @valid
+          check_invalid_value if @invalid
+
+          @result
+        end
+
+        def description
+          desc = []
+          desc << " allowing the value #{@valid.inspect}" if @valid
+          desc << " not allowing the value #{@invalid.inspect}" if @invalid
+          super << desc.to_sentence
+        end
+
+        private
+
+        def check_valid_value
+          if format =~ @valid
+            @positive_message << " with #{@valid.inspect} as a valid value"
+          else
+            @negative_message << " with #{@valid.inspect} as an invalid value"
+            @result = false
+          end
+        end
+
+        def check_invalid_value
+          if !(format =~ @invalid)
+            @positive_message << " with #{@invalid.inspect} as a invalid value"
+          else
+            @negative_message << " with #{@invalid.inspect} as a valid value"
+            @result = false
+          end
+        end
+
+        def format
+          @validator.options[:with]
+        end
+      end
+
+      def validate_format_of(field)
+        ValidateFormatMatcher.new(field)
+      end
+    end
+  end
+end

data/lib/matchers/validations/length_of.rb

@@ -0,0 +1,65 @@
+module Mongoid
+  module Matchers
+    module Validations
+      class ValidateLengthMatcher < HaveValidationMatcher
+        def initialize(field)
+          super(field, :length)
+        end
+
+        def with_minimum(value)
+          @minimum = value
+          self
+        end
+        alias :with_min :with_minimum
+
+        def with_maximum(value)
+          @maximum = value
+          self
+        end
+        alias :with_max :with_maximum
+
+        def matches?(klass)
+          return false unless @result = super(klass)
+
+          check_minimum if @minimum
+          check_maximum if @maximum
+
+          @result
+        end
+
+        def description
+          desc = []
+          desc << " with minimum #{@minimum}" if @minimum
+          desc << " with maximum #{@maximum}" if @maximum
+          super << desc.to_sentence
+        end
+
+        private
+
+        def check_minimum
+          actual = @validator.options[:minimum]
+          if actual == @minimum
+            @positive_message << " with minimum of #{@minimum}"
+          else
+            @negative_message << " with minimum of #{actual}"
+            @result = false
+          end
+        end
+
+        def check_maximum
+          actual = @validator.options[:maximum]
+          if actual == @maximum
+            @positive_message << " with maximum of #{@maximum}"
+          else
+            @negative_message << " with maximum of #{actual}"
+            @result = false
+          end
+        end
+      end
+
+      def validate_length_of(field)
+        ValidateLengthMatcher.new(field)
+      end
+    end
+  end
+end

data/lib/matchers/validations/presence_of.rb

@@ -0,0 +1,9 @@
+module Mongoid
+  module Matchers
+    module Validations
+      def validate_presence_of(field)
+        HaveValidationMatcher.new(field, :presence)
+      end
+    end
+  end
+end

data/lib/matchers/validations/uniqueness_of.rb

@@ -0,0 +1,43 @@
+module Mongoid
+  module Matchers
+    module Validations
+      class ValidateUniquenessMatcher < HaveValidationMatcher
+        def initialize(field)
+          super(field, :uniqueness)
+        end
+
+        def case_insensitive
+          @case_insensitive = true
+          self
+        end
+
+        def matches?(klass)
+          return false unless @result = super(klass)
+
+          check_case_sensivity if @case_insensitive
+
+          @result
+        end
+
+        def check_case_sensivity
+          if @validator.options[:case_sensitive] == false
+            @positive_message << " with case insensitive values"
+          else
+            @negative_message << " without case insensitive values"
+            @result = false
+          end
+        end
+
+        def description
+          desc =  []
+          desc << " allowing case insensitive values" if @case_insensitive
+          super << desc.to_sentence
+        end
+      end
+
+      def validate_uniqueness_of(field)
+        ValidateUniquenessMatcher.new(field)
+      end
+    end
+  end
+end

data/lib/matchers/validations/validations.rb

@@ -0,0 +1,41 @@
+module Mongoid
+  module Matchers
+    module Validations
+      class HaveValidationMatcher
+        include Mongoid::Matchers::Helpers
+
+        def initialize(field, validation_type)
+          @field = field.to_s
+          @type = validation_type.to_s
+        end
+
+        def matches?(actual)
+          @klass = actual.is_a?(Class) ? actual : actual.class
+          @validator = @klass.validators_on(@field).detect { |v| v.kind.to_s == @type }
+
+          if @validator
+            @negative_message = "#{@type.inspect} validator on #{@field.inspect}"
+            @positive_message = "#{@type.inspect} validator on #{@field.inspect}"
+          else
+            @negative_message = "no #{@type.inspect} validator on #{@field.inspect}"
+            return false
+          end
+
+          true
+        end
+
+        def failure_message
+          "Expected #{@klass.inspect} to #{description}; instead got #{@negative_message}"
+        end
+
+        def negative_failure_message
+          "Expected #{@klass.inspect} to not #{description}; instead got #{@positive_message}"
+        end
+
+        def description
+          "validate #{@type.inspect} of #{@field.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/minitest/matchers.rb

@@ -0,0 +1,42 @@
+module MiniTest
+  module Assertions
+    def assert_must(subject, matcher, msg = nil)
+      msg = message(msg) do
+        if matcher.respond_to? :failure_message
+          matcher.failure_message
+        else
+          "Expected #{subject.inspect} to #{matcher.description}"
+        end
+      end
+
+      assert matcher.matches?(subject), msg
+    end
+
+    def assert_wont(subject, matcher, msg = nil)
+      msg = message(msg) do
+        if matcher.respond_to? :negative_failure_message
+          matcher.negative_failure_message
+        else
+          "Expected not to #{matcher.description}"
+        end
+      end
+
+      refute matcher.matches?(subject), msg
+    end
+  end
+
+  module Expectations
+    infect_an_assertion :assert_must, :must, :reverse
+    infect_an_assertion :assert_wont, :wont, :reverse
+  end
+end
+
+class MiniTest::Spec
+  def must(*args, &block)
+    subject.must(*args, &block)
+  end
+
+  def wont(*args, &block)
+    subject.wont(*args, &block)
+  end
+end

data/lib/mongoid-minitest.rb

@@ -0,0 +1,26 @@
+gem "minitest"
+require "mongoid"
+require "minitest/spec"
+
+require "minitest/matchers"
+require "matchers/helpers"
+require "matchers/document/have_field"
+require "matchers/document/be_document"
+require "matchers/document/be_paranoid"
+require "matchers/document/be_versioned"
+require "matchers/document/be_timestamped"
+require "matchers/validations/validations"
+require "matchers/validations/presence_of"
+require "matchers/validations/uniqueness_of"
+require "matchers/validations/length_of"
+require "matchers/validations/format_of"
+require "matchers/validations/exclusion_of"
+require "matchers/associations/associations"
+
+module Mongoid
+  module Matchers
+    include Mongoid::Matchers::Document
+    include Mongoid::Matchers::Validations
+    include Mongoid::Matchers::Associations
+  end
+end

data/lib/mongoid-minitest/version.rb

@@ -0,0 +1,5 @@
+module Mongoid
+  module MiniTest
+    VERSION = "0.0.1"
+  end
+end

data/mongoid-minitest.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/mongoid-minitest/version", __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Francesco Rodriguez"]
+  gem.email         = ["lrodriguezsanc@gmail.com"]
+  gem.description   = %q{Minitest matchers for Mongoid}
+  gem.summary       = %q{Minitest matchers for Mongoid}
+  gem.homepage      = "https://github.com/frodsan/mongoid-minitest"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "mongoid-minitest"
+  gem.require_paths = ["lib"]
+  gem.version       = Mongoid::MiniTest::VERSION
+
+  gem.add_dependency "minitest", "~> 2.12.0"
+  gem.add_dependency "mongoid" , "~> 2.4.7"
+  gem.add_development_dependency "bson_ext", "~> 1.6.1"
+  gem.add_development_dependency "guard-minitest"
+  gem.add_development_dependency "rake", "~> 0.9.2"
+end

data/test/matchers/associations_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+describe Mongoid::Matchers::Associations do
+
+  describe "have_many" do
+    subject { Person }
+
+    it { must have_many(:pets) }
+    it { wont have_many(:accounts) }
+
+    it { must have_many(:pets).of_type(Pet) }
+    it { wont have_many(:pets).of_type(Person) }
+  end
+
+end

data/test/matchers/document_test.rb

@@ -0,0 +1,28 @@
+require "test_helper"
+
+describe Mongoid::Matchers::Document do
+  subject { Person }
+
+  it { must be_document }
+  it { must be_paranoid }
+  it { must be_versioned }
+  it { must be_timestamped }
+
+  it { must have_field(:name) }
+  it { wont have_field(:noexist) }
+
+  it { must have_field(:name).of_type(String) }
+  it { wont have_field(:name).of_type(Integer) }
+
+  it { must have_field(:name).with_default_value("me") }
+  it { wont have_field(:name).with_default_value("nodefault") }
+  it { must have_field(:name).of_type(String).with_default_value("me") }
+  it { wont have_field(:name).of_type(String).with_default_value("nodefault") }
+
+  it { must have_fields(:name, :login) }
+  it { wont have_fields(:noexist, :noexistagain) }
+  it { must have_fields(:name, :login).of_type(String) }
+  it { wont have_fields(:name, :login).of_type(Integer) }
+  it { must have_fields(:name, :login).with_default_value("me") }
+  it { must have_fields(:name, :login).of_type(String).with_default_value("me") }
+end

data/test/matchers/validations_test.rb

@@ -0,0 +1,29 @@
+require "test_helper"
+
+describe Mongoid::Matchers::Validations do
+  subject { Person }
+
+  it { must validate_presence_of(:name) }
+  it { wont validate_presence_of(:age) }
+
+  it { must validate_uniqueness_of(:login).case_insensitive }
+  it { wont validate_uniqueness_of(:email).case_insensitive }
+
+  it { must validate_length_of(:password).with_min(8) }
+  it { wont validate_length_of(:password).with_min(0) }
+  it { must validate_length_of(:password).with_minimum(8) }
+  it { wont validate_length_of(:password).with_minimum(0) }
+  it { must validate_length_of(:password).with_max(16) }
+  it { wont validate_length_of(:password).with_max(8) }
+  it { must validate_length_of(:password).with_maximum(16) }
+  it { wont validate_length_of(:password).with_maximum(8) }
+
+  it { must validate_format_of(:email).to_allow("foo@bar.com") }
+  it { wont validate_format_of(:email).to_allow("foo_bar_com") }
+  it { must validate_format_of(:email).to_not_allow("foo_bar_com") }
+  it { wont validate_format_of(:email).to_not_allow("foo@bar.com") }
+
+  it { must validate_exclusion_of(:email).to_not_allow("foo@bar.com") }
+  it { must validate_exclusion_of(:email).to_not_allow("foo@bar.com", "fizz@buzz.com") }
+  it { wont validate_exclusion_of(:email).to_not_allow("foo_bar.com") }
+end

data/test/models/models.rb

@@ -0,0 +1,25 @@
+class Person
+  include Mongoid::Document
+  include Mongoid::Paranoia
+  include Mongoid::Versioning
+  include Mongoid::Timestamps
+
+  field :login,    type: String,  default: "me"
+  field :password, type: String
+  field :name,     type: String,  default: "me"
+  field :age,      type: Integer
+  field :email,    type: String
+
+  has_many :pets
+
+  validates_presence_of(:name)
+  validates_uniqueness_of(:email)
+  validates_uniqueness_of(:login, case_sensitive: false)
+  validates_length_of(:password, minimum: 8, maximum: 16)
+  validates_format_of(:email, with: /^([^\s]+)((?:[-a-z0-9]\.)[a-z]{2,})$/i)
+  validates_exclusion_of(:email, in: ["foo@bar.com", "fizz@buzz.com"])
+end
+
+class Pet
+  include Mongoid::Document
+end

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+require "mongoid-minitest"
+require "minitest/autorun"
+
+Dir[File.dirname(__FILE__) + "/models/*.rb"].each { |f| require f }
+
+Mongoid.configure do |config|
+  config.master = Mongo::Connection.new.db("mongoid-minitest-test")
+end
+
+class MiniTest::Spec
+  include Mongoid::Matchers
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: mongoid-minitest
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Francesco Rodriguez
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &70195620634560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70195620634560
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: &70195620634020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.4.7
+  type: :runtime
+  prerelease: false
+  version_requirements: *70195620634020
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: &70195620633540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+  type: :development
+  prerelease: false
+  version_requirements: *70195620633540
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: &70195620633040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70195620633040
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70195620632340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: *70195620632340
+description: Minitest matchers for Mongoid
+email:
+- lrodriguezsanc@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rbenv-version
+- CHANGELOG.md
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/matchers/associations/associations.rb
+- lib/matchers/document/be_document.rb
+- lib/matchers/document/be_paranoid.rb
+- lib/matchers/document/be_timestamped.rb
+- lib/matchers/document/be_versioned.rb
+- lib/matchers/document/have_field.rb
+- lib/matchers/helpers.rb
+- lib/matchers/validations/exclusion_of.rb
+- lib/matchers/validations/format_of.rb
+- lib/matchers/validations/length_of.rb
+- lib/matchers/validations/presence_of.rb
+- lib/matchers/validations/uniqueness_of.rb
+- lib/matchers/validations/validations.rb
+- lib/minitest/matchers.rb
+- lib/mongoid-minitest.rb
+- lib/mongoid-minitest/version.rb
+- mongoid-minitest.gemspec
+- test/matchers/associations_test.rb
+- test/matchers/document_test.rb
+- test/matchers/validations_test.rb
+- test/models/models.rb
+- test/test_helper.rb
+homepage: https://github.com/frodsan/mongoid-minitest
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Minitest matchers for Mongoid
+test_files:
+- test/matchers/associations_test.rb
+- test/matchers/document_test.rb
+- test/matchers/validations_test.rb
+- test/models/models.rb
+- test/test_helper.rb