thorsson-mongo_mapper 0.8.2

data/test/models.rb

@@ -0,0 +1,233 @@
+# custom type
+class WindowSize
+  attr_reader :width, :height
+
+  def self.to_mongo(value)
+    value.to_a
+  end
+
+  def self.from_mongo(value)
+    value.is_a?(self) ? value : WindowSize.new(value)
+  end
+
+  def initialize(*args)
+    @width, @height = args.flatten
+  end
+
+  def to_a
+    [width, height]
+  end
+
+  def ==(other)
+    other.is_a?(self.class) && other.width == width && other.height == height
+  end
+end
+
+module AccountsExtensions
+  def inactive
+    all(:last_logged_in => nil)
+  end
+end
+
+class Post
+  include MongoMapper::Document
+
+  key :title, String
+  key :body, String
+
+  many :comments, :as => :commentable, :class_name => 'PostComment'
+
+  timestamps!
+end
+
+class PostComment
+  include MongoMapper::Document
+
+  key :username, String, :default => 'Anonymous'
+  key :body, String
+
+  key :commentable_id, ObjectId
+  key :commentable_type, String
+  belongs_to :commentable, :polymorphic => true
+
+  timestamps!
+end
+
+class Address
+  include MongoMapper::EmbeddedDocument
+
+  key :address, String
+  key :city,    String
+  key :state,   String
+  key :zip,     Integer
+end
+
+class Message
+  include MongoMapper::Document
+
+  key :body, String
+  key :position, Integer
+  key :room_id, ObjectId
+
+  belongs_to :room
+end
+
+class Enter < Message; end
+class Exit < Message;  end
+class Chat < Message;  end
+
+class Room
+  include MongoMapper::Document
+
+  key :name, String
+  many :messages, :polymorphic => true, :order => 'position' do
+    def older
+      all(:position => {'$gt' => 5})
+    end
+  end
+  many :latest_messages, :class_name => 'Message', :order => 'position desc', :limit => 2
+
+  many :accounts, :polymorphic => true, :extend => AccountsExtensions
+end
+
+class Account
+  include MongoMapper::Document
+
+  key :room_id, ObjectId
+  key :last_logged_in, Time
+
+  belongs_to :room
+end
+class AccountUser < Account; end
+class Bot < Account; end
+
+class Answer
+  include MongoMapper::Document
+
+  key :body, String
+end
+
+module CollaboratorsExtensions
+  def top
+    first
+  end
+end
+
+class Project
+  include MongoMapper::Document
+
+  key :name, String
+
+  many :collaborators, :extend => CollaboratorsExtensions
+  many :statuses, :order => 'position' do
+    def open
+      all(:name => %w(New Assigned))
+    end
+  end
+
+  many :addresses do
+    def find_all_by_state(state)
+      # can't use select here for some reason
+      find_all { |a| a.state == state }
+    end
+  end
+end
+
+class Collaborator
+  include MongoMapper::Document
+  key :project_id, ObjectId
+  key :name, String
+  belongs_to :project
+end
+
+class Status
+  include MongoMapper::Document
+
+  scope :complete, where(:name => 'Complete')
+
+  def self.by_position(position)
+    where(:position => position)
+  end
+
+  key :project_id, ObjectId
+  key :target_id, ObjectId
+  key :target_type, String
+  key :name, String, :required => true
+  key :position, Integer
+
+  belongs_to :project
+  belongs_to :target, :polymorphic => true
+end
+
+class Media
+  include MongoMapper::EmbeddedDocument
+
+  key :file, String
+  key :visible, Boolean
+end
+
+class Video < Media
+  key :length, Integer
+end
+
+class Image < Media
+  key :width, Integer
+  key :height, Integer
+end
+
+class Music < Media
+  key :bitrate, String
+end
+
+class Catalog
+  include MongoMapper::Document
+
+  many :medias, :polymorphic => true do
+    def visible
+      # for some reason we can't use select here
+      find_all { |m| m.visible? }
+    end
+  end
+end
+
+module TrModels
+  class Transport
+    include MongoMapper::EmbeddedDocument
+
+    key :license_plate, String
+    key :purchased_on, Date
+  end
+
+  class Car < TrModels::Transport
+    include MongoMapper::EmbeddedDocument
+
+    key :model, String
+    key :year, Integer
+  end
+
+  class Bus < TrModels::Transport
+    include MongoMapper::EmbeddedDocument
+
+    key :max_passengers, Integer
+  end
+
+  class Ambulance < TrModels::Transport
+    include MongoMapper::EmbeddedDocument
+
+    key :icu, Boolean
+  end
+
+  class Fleet
+    include MongoMapper::Document
+
+    module TransportsExtension
+      def to_be_replaced
+        # for some reason we can't use select
+        find_all { |t| t.purchased_on < 2.years.ago.to_date }
+      end
+    end
+
+    many :transports, :polymorphic => true, :class_name => "TrModels::Transport", :extend => TransportsExtension
+    key :name, String
+  end
+end

data/test/test_active_model_lint.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+# For testing against edge rails also.
+# $:.unshift '/Users/jnunemaker/dev/ruby/rails/activemodel/lib'
+require 'active_model'
+require 'models'
+
+class ActiveModelLintTest < ActiveModel::TestCase
+  include ActiveModel::Lint::Tests
+
+  def setup
+    @model = Post.new
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,104 @@
+require 'rubygems'
+gem 'activesupport',     ENV['ACTIVE_SUPPORT_VERSION']
+gem 'json',              '~> 1.2.3'
+gem 'jnunemaker-matchy', '~> 0.4.0'
+gem 'shoulda',           '~> 2.10.2'
+gem 'timecop',           '~> 0.3.1'
+gem 'mocha',             '~> 0.9.8'
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+require 'mongo_mapper'
+require 'fileutils'
+require 'ostruct'
+require 'pp'
+
+require 'active_support/version'
+require 'json'
+require 'matchy'
+require 'shoulda'
+require 'timecop'
+require 'mocha'
+
+class Test::Unit::TestCase
+  def Doc(name=nil, &block)
+    klass = Class.new do
+      include MongoMapper::Document
+      set_collection_name :test
+
+      if name
+        class_eval "def self.name; '#{name}' end"
+        class_eval "def self.to_s; '#{name}' end"
+      end
+    end
+
+    klass.class_eval(&block) if block_given?
+    klass.collection.remove
+    klass
+  end
+
+  def EDoc(name=nil, &block)
+    klass = Class.new do
+      include MongoMapper::EmbeddedDocument
+
+      if name
+        class_eval "def self.name; '#{name}' end"
+        class_eval "def self.to_s; '#{name}' end"
+      end
+    end
+
+    klass.class_eval(&block) if block_given?
+    klass
+  end
+
+  def drop_indexes(klass)
+    if klass.database.collection_names.include?(klass.collection.name)
+      klass.collection.drop_indexes
+    end
+  end
+  
+  custom_matcher :be_true do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected #{receiver} to be true but it wasn't"
+    matcher.negative_failure_message = "Expected #{receiver} not to be true but it was"
+    receiver.eql?(true)
+  end
+
+  custom_matcher :be_false do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected #{receiver} to be false but it wasn't"
+    matcher.negative_failure_message = "Expected #{receiver} not to be false but it was"
+    receiver.eql?(false)
+  end
+
+  custom_matcher :have_error_on do |receiver, matcher, args|
+    receiver.valid?
+    attribute = args[0]
+    expected_message = args[1]
+
+    if expected_message.nil?
+      matcher.positive_failure_message = "#{receiver} had no errors on #{attribute}"
+      matcher.negative_failure_message = "#{receiver} had errors on #{attribute} #{receiver.errors.inspect}"
+      !receiver.errors.on(attribute).blank?
+    else
+      actual = receiver.errors.on(attribute)
+      matcher.positive_failure_message = %Q(Expected error on #{attribute} to be "#{expected_message}" but was "#{actual}")
+      matcher.negative_failure_message = %Q(Expected error on #{attribute} not to be "#{expected_message}" but was "#{actual}")
+      actual == expected_message
+    end
+  end
+
+  custom_matcher :have_index do |receiver, matcher, args|
+    index_name = args[0]
+    matcher.positive_failure_message = "#{receiver} does not have index named #{index_name}, but should"
+    matcher.negative_failure_message = "#{receiver} does have index named #{index_name}, but should not"
+    !receiver.collection.index_information.detect { |index| index[0] == index_name }.nil?
+  end
+end
+
+log_dir = File.expand_path('../../log', __FILE__)
+FileUtils.mkdir_p(log_dir) unless File.exist?(log_dir)
+logger = Logger.new(log_dir + '/test.log')
+
+MongoMapper.connection = Mongo::Connection.new('127.0.0.1', 27017, :logger => logger)
+MongoMapper.database = "mm-test-#{RUBY_VERSION.gsub('.', '-')}"
+MongoMapper.database.collections.each { |c| c.drop_indexes }
+
+puts "\n--- Active Support Version: #{ActiveSupport::VERSION::STRING} ---\n"

data/test/unit/associations/test_base.rb

@@ -0,0 +1,212 @@
+require 'test_helper'
+require 'models'
+
+class FooMonster; end
+
+class AssociationBaseTest < Test::Unit::TestCase
+  include MongoMapper::Plugins::Associations
+
+  should "initialize with type and name" do
+    base = Base.new(:many, :foos)
+    base.type.should == :many
+    base.name.should == :foos
+  end
+
+  should "also allow options when initializing" do
+    base = Base.new(:many, :foos, :polymorphic => true)
+    base.options[:polymorphic].should be_true
+  end
+
+  context "class_name" do
+    should "work for belongs_to" do
+      Base.new(:belongs_to, :user).class_name.should == 'User'
+    end
+
+    should "work for many" do
+      Base.new(:many, :smart_people).class_name.should == 'SmartPerson'
+    end
+
+    should "be changeable using class_name option" do
+      base = Base.new(:many, :smart_people, :class_name => 'IntelligentPerson')
+      base.class_name.should == 'IntelligentPerson'
+    end
+  end
+
+  context "klass" do
+    should "default to class_name constantized" do
+      Base.new(:belongs_to, :foo_monster).klass.should == FooMonster
+    end
+
+    should "be the specified class" do
+      anonnymous_class = Class.new
+      Base.new(:belongs_to, :foo_monster, :class => anonnymous_class).klass.should == anonnymous_class
+    end
+  end
+
+  context "many?" do
+    should "be true if many" do
+      Base.new(:many, :foos).many?.should be_true
+    end
+
+    should "be false if not many" do
+      Base.new(:belongs_to, :foo).many?.should be_false
+      Base.new(:one, :foo).many?.should be_false
+    end
+  end
+
+  context "one?" do
+    should "be true if one" do
+      Base.new(:one, :foo).one?.should be_true
+    end
+
+    should "be false if not one" do
+      Base.new(:many, :foo).one?.should be_false
+    end
+  end
+
+  context "belongs_to?" do
+    should "be true if belongs_to" do
+      Base.new(:belongs_to, :foo).belongs_to?.should be_true
+    end
+
+    should "be false if not belongs_to" do
+      Base.new(:many, :foos).belongs_to?.should be_false
+    end
+  end
+
+  context "polymorphic?" do
+    should "be true if polymorphic" do
+      Base.new(:many, :foos, :polymorphic => true).polymorphic?.should be_true
+    end
+
+    should "be false if not polymorphic" do
+      Base.new(:many, :bars).polymorphic?.should be_false
+    end
+  end
+
+  context "as?" do
+    should "be true if one" do
+      Base.new(:one, :foo, :as => :commentable).as?.should be_true
+    end
+
+    should "be false if not one" do
+      Base.new(:many, :foo).as?.should be_false
+    end
+  end
+
+  context "in_array?" do
+    should "be true if one" do
+      Base.new(:one, :foo, :in => :list_ids).in_array?.should be_true
+    end
+
+    should "be false if not one" do
+      Base.new(:many, :foo).in_array?.should be_false
+    end
+  end
+
+  context "query_options" do
+    should "default to empty hash" do
+      base = Base.new(:many, :foos)
+      base.query_options.should == {}
+    end
+
+    should "work with order" do
+      base = Base.new(:many, :foos, :order => 'position')
+      base.query_options.should == {:order => 'position'}
+    end
+
+    should "correctly parse from options" do
+      base = Base.new(:many, :foos, :order => 'position', :somekey => 'somevalue')
+      base.query_options.should == {:order => 'position', :somekey => 'somevalue'}
+    end
+  end
+
+  context "type_key_name" do
+    should "be _type for many" do
+      Base.new(:many, :foos).type_key_name.should == '_type'
+    end
+
+    should "be association name _ type for belongs_to" do
+      Base.new(:belongs_to, :foo).type_key_name.should == 'foo_type'
+    end
+  end
+
+  context "foreign_key" do
+    should "default to assocation name _id for belongs to" do
+      base = Base.new(:belongs_to, :foo)
+      base.foreign_key.should == 'foo_id'
+    end
+
+    should "be overridable with :foreign_key option" do
+      base = Base.new(:belongs_to, :foo, :foreign_key => 'foobar_id')
+      base.foreign_key.should == 'foobar_id'
+    end
+  end
+
+  should "have ivar that is association name" do
+    Base.new(:belongs_to, :foo).ivar.should == '@_foo'
+  end
+
+  context "embeddable?" do
+    should "be true if class is embeddable" do
+      base = Base.new(:many, :medias)
+      base.embeddable?.should be_true
+    end
+
+    should "be false if class is not embeddable" do
+      base = Base.new(:many, :statuses)
+      base.embeddable?.should be_false
+
+      base = Base.new(:belongs_to, :project)
+      base.embeddable?.should be_false
+    end
+  end
+
+  context "proxy_class" do
+    should "be ManyDocumentsProxy for many" do
+      base = Base.new(:many, :statuses)
+      base.proxy_class.should == ManyDocumentsProxy
+    end
+
+    should "be ManyPolymorphicProxy for polymorphic many" do
+      base = Base.new(:many, :messages, :polymorphic => true)
+      base.proxy_class.should == ManyPolymorphicProxy
+    end
+
+    should "be ManyEmbeddedProxy for many embedded" do
+      base = Base.new(:many, :medias)
+      base.proxy_class.should == ManyEmbeddedProxy
+    end
+
+    should "be ManyEmbeddedPolymorphicProxy for polymorphic many embedded" do
+      base = Base.new(:many, :medias, :polymorphic => true)
+      base.proxy_class.should == ManyEmbeddedPolymorphicProxy
+    end
+
+    should "be BelongsToProxy for belongs_to" do
+      base = Base.new(:belongs_to, :project)
+      base.proxy_class.should == BelongsToProxy
+    end
+
+    should "be BelongsToPolymorphicProxy for polymorphic belongs_to" do
+      base = Base.new(:belongs_to, :target, :polymorphic => true)
+      base.proxy_class.should == BelongsToPolymorphicProxy
+    end
+
+    should "be OneProxy for one" do
+      base = Base.new(:one, :status, :polymorphic => true)
+      base.proxy_class.should == OneProxy
+    end
+
+    should "be OneEmbeddedProxy for one embedded" do
+      base = Base.new(:one, :media)
+      base.proxy_class.should == OneEmbeddedProxy
+    end
+
+    should "be InArrayProxy for many with :in option" do
+      base = Base.new(:many, :messages, :in => :message_ids)
+      base.proxy_class.should == InArrayProxy
+    end
+  end
+
+end