pwnash-mongo_mapper 0.7.5 → 0.7.6

data/test/models.rb

@@ -1,227 +0,0 @@
-# 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
-
-  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/support/custom_matchers.rb

@@ -1,37 +0,0 @@
-module CustomMatchers
-  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

data/test/support/timing.rb

@@ -1,16 +0,0 @@
-class Test::Unit::TestCase
-  def run_with_test_timing(*args, &block)
-    begin_time = Time.now
-    run_without_test_timing(*args, &block)
-    end_time = Time.now
-
-    duration = end_time - begin_time
-    threshold = 5.0
-
-    if duration > threshold
-      puts "\nSLOW TEST: #{duration} - #{self.name}"
-    end
-  end
-
-  alias_method_chain :run, :test_timing unless method_defined?(:run_without_test_timing)
-end

data/test/test_helper.rb

@@ -1,64 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../lib/mongo_mapper')
-require 'fileutils'
-
-gem 'jnunemaker-matchy', '0.4.0'
-gem 'shoulda',           '2.10.2'
-gem 'json',              '>= 1.2.3'
-gem 'timecop',           '0.3.1'
-gem 'mocha',             '0.9.8'
-
-require 'ostruct'
-require 'shoulda'
-require 'timecop'
-require 'matchy'
-require 'mocha'
-require 'json'
-require 'pp'
-
-require 'support/custom_matchers'
-
-class Test::Unit::TestCase
-  include CustomMatchers
-
-  def Doc(name=nil, &block)
-    klass = Class.new do
-      include MongoMapper::Document
-      set_collection_name "test#{rand(20)}"
-
-      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
-end
-
-test_dir = File.expand_path(File.dirname(__FILE__) + '/../tmp')
-FileUtils.mkdir_p(test_dir) unless File.exist?(test_dir)
-
-MongoMapper.connection = Mongo::Connection.new('127.0.0.1', 27017, {:logger => Logger.new(test_dir + '/test.log')})
-MongoMapper.database = 'test'

data/test/unit/associations/test_base.rb

@@ -1,212 +0,0 @@
-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