pwnash-mongo_mapper 0.7.5 → 0.7.6

data/test/unit/test_plugins.rb

@@ -1,50 +0,0 @@
-require 'test_helper'
-
-module MyPlugin
-  def self.configure(model)
-    model.class_eval { attr_accessor :from_configure }
-  end
-
-  module ClassMethods
-    def class_foo
-      'class_foo'
-    end
-  end
-
-  module InstanceMethods
-    def instance_foo
-      'instance_foo'
-    end
-  end
-end
-
-class PluginsTest < Test::Unit::TestCase
-  context "plugin" do
-    setup do
-      @document = Class.new do
-        extend MongoMapper::Plugins
-        plugin MyPlugin
-      end
-    end
-
-    should "include instance methods" do
-      @document.new.instance_foo.should == 'instance_foo'
-    end
-
-    should "extend class methods" do
-      @document.class_foo.should == 'class_foo'
-    end
-
-    should "pass model to configure" do
-      @document.new.should respond_to(:from_configure)
-    end
-
-    should "default plugins to empty array" do
-      Class.new { extend MongoMapper::Plugins }.plugins.should == []
-    end
-
-    should "add plugin to plugins" do
-      @document.plugins.should include(MyPlugin)
-    end
-  end
-end

data/test/unit/test_query.rb

@@ -1,374 +0,0 @@
-require 'test_helper'
-require 'models'
-
-class QueryTest < Test::Unit::TestCase
-  include MongoMapper
-
-  should "raise error if provided something other than a hash" do
-    lambda { Query.new(Room) }.should raise_error(ArgumentError)
-    lambda { Query.new(Room, 1) }.should raise_error(ArgumentError)
-  end
-
-  should "symbolize the keys of the hash provided" do
-    Query.new(Room, 'offset' => 1).options.keys.map do |key|
-      key.should be_instance_of(Symbol)
-    end
-  end
-
-  context "Converting conditions to criteria" do
-    should "not add _type to query if model does not have superclass that is single collection inherited" do
-      Query.new(Message, :foo => 'bar').criteria.should == {
-        :foo => 'bar'
-      }
-    end
-
-    should "not add _type to nested conditions" do
-      Query.new(Enter, :foo => 'bar', :age => {'$gt' => 21}).criteria.should == {
-        :foo => 'bar',
-        :age => {'$gt' => 21},
-        :_type => 'Enter'
-      }
-    end
-
-    should "automatically add _type to query if model is single collection inherited" do
-      Query.new(Enter, :foo => 'bar').criteria.should == {
-        :foo => 'bar',
-        :_type => 'Enter'
-      }
-    end
-
-    %w{gt lt gte lte ne in nin mod all size where exists}.each do |operator|
-      next if operator == 'size' && RUBY_VERSION >= '1.9.1' # 1.9 defines Symbol#size
-
-      should "convert #{operator} conditions" do
-        Query.new(Room, :age.send(operator) => 21).criteria.should == {
-          :age => {"$#{operator}" => 21}
-        }
-      end
-    end
-
-    should "normalize value when using symbol operators" do
-      time = Time.now.in_time_zone('Indiana (East)')
-      criteria = Query.new(Room, :created_at.gt => time).criteria
-      criteria[:created_at]['$gt'].should be_utc
-    end
-
-    should "work with multiple symbol operators on the same field" do
-      Query.new(Message, :position.gt => 0, :position.lte => 10).criteria.should == {
-        :position => {"$gt" => 0, "$lte" => 10}
-      }
-    end
-
-    should "work with simple criteria" do
-      Query.new(Room, :foo => 'bar').criteria.should == {
-        :foo => 'bar'
-      }
-
-      Query.new(Room, :foo => 'bar', :baz => 'wick').criteria.should == {
-        :foo => 'bar',
-        :baz => 'wick'
-      }
-    end
-
-    should "convert id to _id" do
-      id = BSON::ObjectID.new
-      Query.new(Room, :id => id).criteria.should == {:_id => id}
-    end
-
-    should "convert id with symbol operator to _id with modifier" do
-      id = BSON::ObjectID.new
-      Query.new(Room, :id.ne => id).criteria.should == {
-        :_id => {'$ne' => id}
-      }
-    end
-
-    should "make sure that _id's are object ids" do
-      id = BSON::ObjectID.new
-      Query.new(Room, :_id => id.to_s).criteria.should == {:_id => id}
-    end
-
-    should "work fine with _id's that are object ids" do
-      id = BSON::ObjectID.new
-      Query.new(Room, :_id => id).criteria.should == {:_id => id}
-    end
-
-    should "make sure other object id typed keys get converted" do
-      id = BSON::ObjectID.new
-      Query.new(Message, :room_id => id.to_s).criteria.should == {:room_id => id}
-    end
-
-    should "work fine with object ids for object id typed keys" do
-      id = BSON::ObjectID.new
-      Query.new(Message, :room_id => id).criteria.should == {:room_id => id}
-    end
-
-    should "convert times to utc if they aren't already" do
-      time = Time.now.in_time_zone('Indiana (East)')
-      criteria = Query.new(Room, :created_at => time).criteria
-      criteria[:created_at].utc?.should be_true
-    end
-
-    should "not funk with times already in utc" do
-      time = Time.now.utc
-      criteria = Query.new(Room, :created_at => time).criteria
-      criteria[:created_at].utc?.should be_true
-      criteria[:created_at].should == time
-    end
-
-    should "use $in for arrays" do
-      Query.new(Room, :foo => [1,2,3]).criteria.should == {
-        :foo => {'$in' => [1,2,3]}
-      }
-    end
-
-    should "not use $in for arrays if already using array operator" do
-      Query.new(Room, :foo => {'$all' => [1,2,3]}).criteria.should == {
-        :foo => {'$all' => [1,2,3]}
-      }
-
-      Query.new(Room, :foo => {'$any' => [1,2,3]}).criteria.should == {
-        :foo => {'$any' => [1,2,3]}
-      }
-    end
-
-    should "use $in for sets" do
-      Query.new(Room, :foo => Set.new([1,2,3])).criteria.should == {
-        :foo => {'$in' => [1,2,3]}
-      }
-    end
-
-    should "not use $in for sets if already using array operator" do
-      Query.new(Room, :foo => {'$all' => Set.new([1,2,3])}).criteria.should == {
-        :foo => {'$all' => [1,2,3]}
-      }
-
-      Query.new(Room, :foo => {'$any' => Set.new([1,2,3])}).criteria.should == {
-        :foo => {'$any' => [1,2,3]}
-      }
-    end
-
-    should "work arbitrarily deep" do
-      Query.new(Room, :foo => {:bar => [1,2,3]}).criteria.should == {
-        :foo => {:bar => {'$in' => [1,2,3]}}
-      }
-
-      Query.new(Room, :foo => {:bar => {'$any' => [1,2,3]}}).criteria.should == {
-        :foo => {:bar => {'$any' => [1,2,3]}}
-      }
-    end
-
-    should "make sure that ids in array are object ids" do
-      id1, id2, id3 = BSON::ObjectID.new, BSON::ObjectID.new, BSON::ObjectID.new
-
-      Query.new(Room, :_id => [id1.to_s, id2.to_s, id3.to_s]).criteria.should == {
-        :_id => {'$in' => [id1, id2, id3]}
-      }
-    end
-  end
-
-  context "ordering" do
-    should "single field with ascending direction" do
-      sort = [['foo', 1]]
-      Query.new(Room, :order => 'foo asc').options[:sort].should == sort
-      Query.new(Room, :order => 'foo ASC').options[:sort].should == sort
-    end
-
-    should "single field with descending direction" do
-      sort = [['foo', -1]]
-      Query.new(Room, :order => 'foo desc').options[:sort].should == sort
-      Query.new(Room, :order => 'foo DESC').options[:sort].should == sort
-    end
-
-    should "convert order operators to mongo sort" do
-      Query.new(Room, :order => :foo.asc).options[:sort].should == [['foo', 1]]
-      Query.new(Room, :order => :foo.desc).options[:sort].should == [['foo', -1]]
-    end
-
-    should "convert array of order operators to mongo sort" do
-      Query.new(Room, :order => [:foo.asc, :bar.desc]).options[:sort].should == [['foo', 1], ['bar', -1]]
-    end
-
-    should "convert field without direction to ascending" do
-      sort = [['foo', 1]]
-      Query.new(Room, :order => 'foo').options[:sort].should == sort
-    end
-
-    should "convert multiple fields with directions" do
-      sort = [['foo', -1], ['bar', 1], ['baz', -1]]
-      Query.new(Room, :order => 'foo desc, bar asc, baz desc').options[:sort].should == sort
-    end
-
-    should "convert multiple fields with some missing directions" do
-      sort = [['foo', -1], ['bar', 1], ['baz', 1]]
-      Query.new(Room, :order => 'foo desc, bar, baz').options[:sort].should == sort
-    end
-
-    should "just use sort if sort and order are present" do
-      sort = [['$natural', 1]]
-      Query.new(Room, :sort => sort, :order => 'foo asc').options[:sort].should == sort
-    end
-
-    should "normalize id to _id" do
-      Query.new(Room, :order => :id.asc).options[:sort].should == [['_id', 1]]
-    end
-
-    should "convert natural in order to proper" do
-      sort = [['$natural', 1]]
-      Query.new(Room, :order => '$natural asc').options[:sort].should == sort
-      sort = [['$natural', -1]]
-      Query.new(Room, :order => '$natural desc').options[:sort].should == sort
-    end
-
-    should "work for natural order ascending" do
-      Query.new(Room, :sort => {'$natural' => 1}).options[:sort]['$natural'].should == 1
-    end
-
-    should "work for natural order descending" do
-      Query.new(Room, :sort => {'$natural' => -1}).options[:sort]['$natural'].should == -1
-    end
-  end
-
-  context "skip" do
-    should "default to 0" do
-      Query.new(Room, {}).options[:skip].should == 0
-    end
-
-    should "use skip provided" do
-      Query.new(Room, :skip => 2).options[:skip].should == 2
-    end
-
-    should "covert string to integer" do
-      Query.new(Room, :skip => '2').options[:skip].should == 2
-    end
-
-    should "convert offset to skip" do
-      Query.new(Room, :offset => 1).options[:skip].should == 1
-    end
-  end
-
-  context "limit" do
-    should "default to 0" do
-      Query.new(Room, {}).options[:limit].should == 0
-    end
-
-    should "use limit provided" do
-      Query.new(Room, :limit => 2).options[:limit].should == 2
-    end
-
-    should "covert string to integer" do
-      Query.new(Room, :limit => '2').options[:limit].should == 2
-    end
-  end
-
-  context "fields" do
-    should "default to nil" do
-      Query.new(Room, {}).options[:fields].should be(nil)
-    end
-
-    should "be converted to nil if empty string" do
-      Query.new(Room, :fields => '').options[:fields].should be(nil)
-    end
-
-    should "be converted to nil if []" do
-      Query.new(Room, :fields => []).options[:fields].should be(nil)
-    end
-
-    should "should work with array" do
-      Query.new(Room, {:fields => %w(a b)}).options[:fields].should == %w(a b)
-    end
-
-    should "convert comma separated list to array" do
-      Query.new(Room, {:fields => 'a, b'}).options[:fields].should == %w(a b)
-    end
-
-    should "also work as select" do
-      Query.new(Room, :select => %w(a b)).options[:fields].should == %w(a b)
-    end
-
-    should "also work with select as array of symbols" do
-      Query.new(Room, :select => [:a, :b]).options[:fields].should == [:a, :b]
-    end
-
-    should "work with select as hash" do
-      Query.new(Room, :select => {:a => 0, :b => 1}).options[:fields].should == {:a => 0, :b => 1}
-    end
-  end
-
-  context "Condition auto-detection" do
-    should "know :conditions are criteria" do
-      finder = Query.new(Room, :conditions => {:foo => 'bar'})
-      finder.criteria.should == {:foo => 'bar'}
-      finder.options.keys.should_not include(:conditions)
-    end
-
-    should "know fields is an option" do
-      finder = Query.new(Room, :fields => ['foo'])
-      finder.options[:fields].should == ['foo']
-      finder.criteria.keys.should_not include(:fields)
-    end
-
-    # select gets converted to fields so just checking keys
-    should "know select is an option" do
-      finder = Query.new(Room, :select => 'foo')
-      finder.options.keys.should include(:sort)
-      finder.criteria.keys.should_not include(:select)
-      finder.criteria.keys.should_not include(:fields)
-    end
-
-    should "know skip is an option" do
-      finder = Query.new(Room, :skip => 10)
-      finder.options[:skip].should == 10
-      finder.criteria.keys.should_not include(:skip)
-    end
-
-    # offset gets converted to skip so just checking keys
-    should "know offset is an option" do
-      finder = Query.new(Room, :offset => 10)
-      finder.options.keys.should include(:skip)
-      finder.criteria.keys.should_not include(:skip)
-      finder.criteria.keys.should_not include(:offset)
-    end
-
-    should "know limit is an option" do
-      finder = Query.new(Room, :limit => 10)
-      finder.options[:limit].should == 10
-      finder.criteria.keys.should_not include(:limit)
-    end
-
-    should "know sort is an option" do
-      finder = Query.new(Room, :sort => [['foo', 1]])
-      finder.options[:sort].should == [['foo', 1]]
-      finder.criteria.keys.should_not include(:sort)
-    end
-
-    # order gets converted to sort so just checking keys
-    should "know order is an option" do
-      finder = Query.new(Room, :order => 'foo')
-      finder.options.keys.should include(:sort)
-      finder.criteria.keys.should_not include(:sort)
-    end
-
-    should "work with full range of things" do
-      query_options = Query.new(Room, {
-        :foo => 'bar',
-        :baz => true,
-        :sort => [['foo', 1]],
-        :fields => ['foo', 'baz'],
-        :limit => 10,
-        :skip => 10,
-      })
-
-      query_options.criteria.should == {
-        :foo => 'bar',
-        :baz => true,
-      }
-
-      query_options.options.should == {
-        :sort => [['foo', 1]],
-        :fields => ['foo', 'baz'],
-        :limit => 10,
-        :skip => 10,
-      }
-    end
-  end
-end

data/test/unit/test_rails.rb

@@ -1,181 +0,0 @@
-require 'test_helper'
-
-class TestRails < Test::Unit::TestCase
-  context "Document" do
-    setup do
-      @klass = Doc('Post') do
-        key :foo, String
-      end
-    end
-
-    context "Class methods" do
-      should "alias has_many to many" do
-        @klass.should respond_to(:has_many)
-      end
-
-      should "alias has_one to one" do
-        @klass.should respond_to(:has_one)
-      end
-
-      should "have column names" do
-        @klass.column_names.sort.should == ['_id', 'foo']
-      end
-
-      should "implement human_name" do
-        @klass.human_name.should == 'Post'
-      end
-    end
-
-    context "Instance methods" do
-      setup do
-        @klass.class_eval do
-          def bar=(value)
-            write_attribute(:foo, value)
-          end
-
-          def bar_before_typecast
-            read_attribute_before_typecast(:foo)
-          end
-
-          def bar
-            read_attribute(:foo)
-          end
-        end
-      end
-
-      should "alias new_record? to new?" do
-        @klass.new.should be_new_record
-      end
-
-      should "be able to read key with read_attribute" do
-        @klass.new(:foo => 'Bar').bar.should == 'Bar'
-      end
-
-      should "be able to read key before typecast with read_attribute_before_typecast" do
-        @klass.new(:foo => 21).bar_before_typecast.should == 21
-        @klass.new(:foo => 21).bar.should == '21'
-      end
-
-      should "be able to write key with write_attribute" do
-        @klass.new(:bar => 'Setting Foo').foo.should == 'Setting Foo'
-      end
-
-      context '#to_param' do
-        should "be nil if not persisted" do
-          @klass.new.tap do |doc|
-            doc.to_param.should be_nil
-          end
-        end
-
-        should "array representation of id if persisted" do
-          @klass.create.tap do |doc|
-            doc.to_param.should == doc.id.to_s
-          end
-        end
-      end
-
-      context '#to_key' do
-        should "be nil if not persisted" do
-          @klass.new.tap do |doc|
-            doc.to_key.should be_nil
-          end
-        end
-
-        should "array representation of id if persisted" do
-          @klass.create.tap do |doc|
-            doc.to_key.should == [doc.id]
-          end
-        end
-      end
-    end
-  end
-
-  context "EmbeddedDocument" do
-    setup do
-      @klass = EDoc('Post') { key :foo, String }
-    end
-
-    context "Class methods" do
-      should "alias has_many to many" do
-        @klass.should respond_to(:has_many)
-      end
-
-      should "alias has_one to one" do
-        @klass.should respond_to(:has_one)
-      end
-
-      should "have column names" do
-        @klass.column_names.sort.should == ['_id', 'foo']
-      end
-
-      should "implement human_name" do
-        @klass.human_name.should == 'Post'
-      end
-    end
-
-    context "Instance methods" do
-      setup do
-        @klass.class_eval do
-          def bar=(value)
-            write_attribute(:foo, value)
-          end
-
-          def bar_before_typecast
-            read_attribute_before_typecast(:foo)
-          end
-
-          def bar
-            read_attribute(:foo)
-          end
-        end
-      end
-
-      should "alias new_record? to new?" do
-        @klass.new.should be_new_record
-      end
-
-      should "be able to read key with read_attribute" do
-        @klass.new(:foo => 'Bar').bar.should == 'Bar'
-      end
-
-      should "be able to read key before typecast with read_attribute_before_typecast" do
-        @klass.new(:foo => 21).bar_before_typecast.should == 21
-        @klass.new(:foo => 21).bar.should == '21'
-      end
-
-      should "be able to write key with write_attribute" do
-        @klass.new(:bar => 'Setting Foo').foo.should == 'Setting Foo'
-      end
-
-      context '#to_param' do
-        should "be nil if not persisted" do
-          @klass.new.tap do |doc|
-            doc.to_param.should be_nil
-          end
-        end
-
-        should "array representation of id if persisted" do
-          @klass.new.tap do |doc|
-            doc.expects(:persisted?).returns(true)
-            doc.to_param.should == doc.id.to_s
-          end
-        end
-      end
-
-      context '#to_key' do
-        should "be nil if not persisted" do
-          @klass.new.tap do |doc|
-            doc.to_key.should be_nil
-          end
-        end
-
-        should "array representation of id if persisted" do
-          @klass.new.tap do |doc|
-            doc.expects(:persisted?).returns(true)
-            doc.to_key.should == [doc.id]
-          end
-        end
-      end
-    end
-  end
-end