mongo_mapper 0.13.0.beta2 → 0.15.0

data/spec/functional/document_spec.rb

@@ -130,6 +130,34 @@ describe "Document" do
     end
   end
 
+  context "symbol key" do
+    before do
+      @document.key :foo, Symbol, :default => lambda { 123 }
+    end
+
+    it "should return default value" do
+      doc = @document.new
+      doc.foo.should == :'123'
+    end
+
+    it "should return symbol value" do
+      doc = @document.create :foo => 'qwerty'
+      doc.foo.should == :qwerty
+
+      doc.set :foo => 'poiuyt'
+      doc.reload
+      doc.foo.should == :poiuyt
+
+      doc.foo = 'asdf'
+      doc.foo.should == :asdf
+    end
+
+    it "should return typecasted value" do
+      doc = @document.new
+      (doc.foo = 'qwerty').should == 'qwerty'
+    end
+  end
+
   it "should have instance method for collection" do
     @document.new.collection.name.should == @document.collection.name
   end
@@ -243,7 +271,7 @@ describe "Document" do
 
     it "should raise DocumentNotFound if not found" do
       @instance.destroy
-      expect { @instance.reload }.to raise_error(MongoMapper::DocumentNotFound)
+      lambda { @instance.reload }.should raise_error(MongoMapper::DocumentNotFound)
     end
 
     it "should clear keys that were removed from the database" do
@@ -255,7 +283,7 @@ describe "Document" do
   context "database has keys not defined in model" do
     before do
       @id = BSON::ObjectId.new
-      @document.collection.insert({
+      @document.collection.insert_one({
         :_id            => @id,
         :first_name     => 'John',
         :last_name      => 'Nunemaker',

data/spec/functional/dumpable_spec.rb

@@ -7,7 +7,7 @@ describe "Documents with the Dumpable plugin" do
   let(:store)  { ActiveSupport::Cache::MemoryStore.new(:size => 1.megabyte) }
 
   it "should be able to be marshalled" do
-    expect { Marshal.dump(answer) }.to_not raise_error
+    lambda { Marshal.dump(answer) }.should_not raise_error
   end
 
   it "should be able to be unmarshalled" do

data/spec/functional/embedded_document_spec.rb

@@ -70,14 +70,14 @@ describe "EmbeddedDocument" do
     it "should be true until document is created" do
       address = @address_class.new(:city => 'South Bend', :state => 'IN')
       doc = @klass.new(:foo => address)
-      address.new?.should be_true
+      address.new?.should be_truthy
     end
 
     it "should be false after document is saved" do
       address = @address_class.new(:city => 'South Bend', :state => 'IN')
       doc = @klass.new(:foo => address)
       doc.save
-      doc.foo.new?.should be_false
+      doc.foo.new?.should be_falsey
     end
 
     it "should be false when loaded from database" do
@@ -86,7 +86,7 @@ describe "EmbeddedDocument" do
       doc.save
 
       doc.reload
-      doc.foo.new?.should be_false
+      doc.foo.new?.should be_falsey
     end
   end
 
@@ -115,9 +115,9 @@ describe "EmbeddedDocument" do
     it "should be true until existing document is saved" do
       @doc.save
       pet = @doc.pets.build(:name => 'Rasmus')
-      pet.new?.should be_true
+      pet.new?.should be_truthy
       @doc.save
-      pet.new?.should be_false
+      pet.new?.should be_falsey
     end
   end
 
@@ -131,9 +131,9 @@ describe "EmbeddedDocument" do
 
     it "should be true until existing document is saved" do
       address = @doc.pets.first.addresses.build(:city => 'Holland', :state => 'MI')
-      address.new?.should be_true
+      address.new?.should be_truthy
       @doc.save
-      address.new?.should be_false
+      address.new?.should be_falsey
     end
   end
 
@@ -146,9 +146,9 @@ describe "EmbeddedDocument" do
     it "should be true until existing document is saved" do
       @doc.save
       @doc.build_address(:city => 'Holland', :state => 'MI')
-      @doc.address.new?.should be_true
+      @doc.address.new?.should be_truthy
       @doc.save
-      @doc.address.new?.should be_false
+      @doc.address.new?.should be_falsey
     end
   end
 
@@ -162,9 +162,9 @@ describe "EmbeddedDocument" do
 
     it "should be true until existing document is saved" do
       address = @doc.pets.first.build_address(:city => 'Holland', :stats => 'MI')
-      address.new?.should be_true
+      address.new?.should be_truthy
       @doc.save
-      address.new?.should be_false
+      address.new?.should be_falsey
     end
   end
 
@@ -248,7 +248,7 @@ describe "EmbeddedDocument" do
     person.reload
     pet = person.pets.first
 
-    pet.update_attribute('name', 'koda').should be_true
+    pet.update_attribute('name', 'koda').should be_truthy
     person.reload
     person.pets.first._id.should == pet._id
     person.pets.first.name.should == 'koda'
@@ -260,7 +260,7 @@ describe "EmbeddedDocument" do
     person.reload
     pet = person.pets.first
 
-    pet.update_attributes(:name => 'koda').should be_true
+    pet.update_attributes(:name => 'koda').should be_truthy
     person.reload
     person.pets.first._id.should == pet._id
     person.pets.first.name.should == 'koda'
@@ -288,8 +288,8 @@ describe "EmbeddedDocument" do
   end
 
   it "should not fail if the source document contains nils in the embedded document list" do
-    @klass.collection.insert(:pets => [nil, {:name => "Sasha"}])
-    expect { @klass.all.first.pets }.to_not raise_error
+    @klass.collection.insert_one(:pets => [nil, {:name => "Sasha"}])
+    lambda { @klass.all.first.pets }.should_not raise_error
     @klass.all.first.pets.tap do |pets|
       pets.length.should == 1
       pets[0].name.should == "Sasha"
@@ -302,15 +302,15 @@ describe "EmbeddedDocument" do
       person.update_attributes!({"pets" => ["name" => "sparky", "flag" => "false"]})
       person.reload
       person.pets.first.name.should == "sparky"
-      person.pets.first.flag.should be_false
+      person.pets.first.flag.should be_falsey
     end
 
      it "should update attributes with symbol keys" do
        person = @klass.create(:pets => [@pet_klass.new(:name => 'Rasmus', :flag => true)])
-       person.update_attributes!({pets: [:name => "sparky", :flag => "false"]})
+       person.update_attributes!({:pets => [:name => "sparky", :flag => "false"]})
        person.reload
        person.pets.first.name.should == "sparky"
-       person.pets.first.flag.should be_false
+       person.pets.first.flag.should be_falsey
     end
   end
 end

data/spec/functional/identity_map_spec.rb

@@ -3,13 +3,13 @@ require 'spec_helper'
 describe "IdentityMap" do
   def assert_in_map(*resources)
     [resources].flatten.each do |resource|
-      MongoMapper::Plugins::IdentityMap.include?(resource).should be_true
+      MongoMapper::Plugins::IdentityMap.include?(resource).should be_truthy
     end
   end
 
   def assert_not_in_map(*resources)
     [resources].flatten.each do |resource|
-      MongoMapper::Plugins::IdentityMap.include?(resource).should be_false
+      MongoMapper::Plugins::IdentityMap.include?(resource).should be_falsey
     end
   end
 
@@ -19,7 +19,7 @@ describe "IdentityMap" do
   end
 
   def expects_one_query
-    Mongo::Collection.any_instance.should_receive(:find_one).once.and_return({})
+    Mongo::Collection.any_instance.should_receive(:find).once.and_call_original
   end
 
   def clear_identity_map
@@ -27,7 +27,7 @@ describe "IdentityMap" do
   end
 
   it "should default identity map to off" do
-    MongoMapper::Plugins::IdentityMap.enabled?.should be_false
+    MongoMapper::Plugins::IdentityMap.enabled?.should be_falsey
   end
 
   context "Document" do
@@ -84,16 +84,16 @@ describe "IdentityMap" do
         MongoMapper::Plugins::IdentityMap.use do
           @person_class.find(@person.id)
         end
-        MongoMapper::Plugins::IdentityMap.repository.empty?.should be_true
+        MongoMapper::Plugins::IdentityMap.repository.empty?.should be_truthy
       end
 
       it "should set enabled back to original status" do
         MongoMapper::Plugins::IdentityMap.enabled = false
-        MongoMapper::Plugins::IdentityMap.enabled?.should be_false
+        MongoMapper::Plugins::IdentityMap.enabled?.should be_falsey
         MongoMapper::Plugins::IdentityMap.use do
-          MongoMapper::Plugins::IdentityMap.enabled?.should be_true
+          MongoMapper::Plugins::IdentityMap.enabled?.should be_truthy
         end
-        MongoMapper::Plugins::IdentityMap.enabled?.should be_false
+        MongoMapper::Plugins::IdentityMap.enabled?.should be_falsey
       end
     end
 
@@ -111,11 +111,11 @@ describe "IdentityMap" do
 
       it "should set enabled back to original value" do
         MongoMapper::Plugins::IdentityMap.enabled = true
-        MongoMapper::Plugins::IdentityMap.enabled?.should be_true
+        MongoMapper::Plugins::IdentityMap.enabled?.should be_truthy
         MongoMapper::Plugins::IdentityMap.without do
-          MongoMapper::Plugins::IdentityMap.enabled?.should be_false
+          MongoMapper::Plugins::IdentityMap.enabled?.should be_falsey
         end
-        MongoMapper::Plugins::IdentityMap.enabled?.should be_true
+        MongoMapper::Plugins::IdentityMap.enabled?.should be_truthy
       end
     end
 
@@ -126,14 +126,14 @@ describe "IdentityMap" do
     it "should add key to map when saved" do
       person = @person_class.new
       assert_not_in_map(person)
-      person.save.should be_true
+      person.save.should be_truthy
       assert_in_map(person)
     end
 
     it "should allow saving with options" do
       person = @person_class.new
       assert_not_in_map(person)
-      person.save(:validate => false).should be_true
+      person.save(:validate => false).should be_truthy
       assert_in_map(person)
     end
 
@@ -178,6 +178,19 @@ describe "IdentityMap" do
         second_load = @person_class.load('_id' => @id, 'name' => 'Frank')
         first_load.should equal(second_load)
       end
+
+      it "should allow passing with_cast" do
+        person_with_time_class = Doc('PersonWithTime') do
+          key :name, String
+          key :created_at, Time
+        end
+
+        lambda do
+          loaded = person_with_time_class.load({'_id' => @id, 'name' => 'Frank', 'created_at' => '2014-12-07T20:36:45.529-08:00'}, true)
+          loaded.should be_present
+          loaded.created_at.should be_an_instance_of(Time)
+        end.should_not raise_error
+      end
     end
 
     context "#find (with one id)" do
@@ -407,7 +420,7 @@ describe "IdentityMap" do
           belongs_to :parent, :class_name => 'Item'
           one :blog, :class_name => 'Blog', :foreign_key => 'parent_id'
         end
-        Item.collection.remove
+        Item.collection.drop
 
         class ::Blog < ::Item; end
 

data/spec/functional/indexes_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe "Indexing" do
   before do
     @document = Doc do
-      key :first_name, String
+      key :first_name, String, :alias => :fn
       key :last_name, String
       key :age, Integer
       key :date, Date
@@ -11,38 +11,63 @@ describe "Indexing" do
   end
   after { drop_indexes(@document) }
 
-  [:create_index, :ensure_index, :drop_index, :drop_indexes].each do |method|
-    it "should delegate #{method} to collection" do
-      @document.stub(:collection).and_return(double(:name => :foo))
-      @document.collection.should_receive(method).with(:arg)
-      @document.send(method, :arg)
+  context "against a known collection" do
+    before do
+      @document.stub(:collection).and_return(double(:name => :foo, :indexes => double()))
+    end
+
+    it "should delegate create_index to collection#create_one" do
+      @document.collection.indexes.should_receive(:create_one).with({:arg => 1}, {})
+      @document.create_index(:arg)
+    end
+
+    it "should delegate ensure_index to collection#create_one" do
+      @document.collection.indexes.should_receive(:create_one).with({:arg => 1}, {})
+      @document.create_index(:arg)
+    end
+    it "should delegate drop_index to collection" do
+      @document.collection.indexes.should_receive(:drop_one).with(:arg)
+      @document.drop_index(:arg)
+    end
+
+    it "should delegate drop_indexes to collection" do
+      @document.collection.indexes.should_receive(:drop_all)
+      @document.drop_indexes
     end
   end
 
-  it "should allow creating index for a key" do
+  it "should allow creating index for an aliased key" do
     @document.ensure_index :first_name
-    @document.should have_index('first_name_1')
+    @document.should have_index('fn_1')
+  end
+
+  it "should allow creating index for an aliased key without using the alias" do
+    @document.ensure_index :fn
+    @document.should have_index('fn_1')
+  end
+
+  it "should allow creating index for an unaliased key" do
+    @document.ensure_index :last_name
+    @document.should have_index('last_name_1')
+  end
+
+  it "should allow specifying as a hash" do
+    @document.ensure_index({last_name: -1})
+    @document.should have_index('last_name_-1')
   end
 
   it "should allow creating unique index for a key" do
     @document.ensure_index :first_name, :unique => true
-    @document.should have_index('first_name_1')
+    @document.should have_index('fn_1')
   end
 
   it "should allow creating index on multiple keys" do
     @document.ensure_index [[:first_name, 1], [:last_name, -1]]
-
-    # order is different for different versions of ruby so instead of
-    # just checking have_index('first_name_1_last_name_-1') I'm checking
-    # the values of the indexes to make sure the index creation was successful
-    @document.collection.index_information.detect do |index|
-      keys = index[0]
-      keys.include?('first_name_1') && keys.include?('last_name_-1')
-    end.should_not be_nil
+    @document.should have_index('fn_1_last_name_-1')
   end
 
   it "should work with :index shortcut when defining key" do
-    silence_stderr { @document.key :father, String, :index => true }
+    suppress_stderr { @document.key :father, String, :index => true }
     @document.should have_index('father_1')
   end
-end
+end

data/spec/functional/keys_spec.rb

@@ -24,6 +24,41 @@ describe "Keys" do
     instance.get_foo.should == instance.foo
   end
 
+  it "should return the value when set using send with the writer method" do
+    doc = Doc do
+      key :foo, String
+    end
+
+    instance = doc.new(:foo => 'bar')
+    instance.send("foo=", 'baz').should == 'baz'
+    instance.foo.should == 'baz'
+  end
+
+  context "when persisting an typecasted array" do
+    TypecastedKeyModel = Doc do
+      key :people, Array, :typecast => "Person"
+    end
+
+    Person = Struct.new(:name) do
+      def self.to_mongo(value)
+        value.name
+      end
+
+      def self.from_mongo(value)
+        Person.new value
+      end
+    end
+
+    it "should not mutate the model's state" do
+      person = Person.new "Bob"
+      doc = TypecastedKeyModel.new(:people => [person])
+
+      doc.save
+
+      doc.people.should == [person]
+    end
+  end
+
   it "should not bomb if a key is written before Keys#initialize gets to get called" do
     doc = Class.new do
       include MongoMapper::Document
@@ -35,7 +70,7 @@ describe "Keys" do
       end
     end
 
-    expect { doc.new }.to_not raise_error
+    lambda { doc.new }.should_not raise_error
   end
 
   it "should not bomb if a key is read before Keys#initialize gets to get called" do
@@ -49,7 +84,7 @@ describe "Keys" do
       end
     end
 
-    expect { doc.new }.to_not raise_error
+    lambda { doc.new }.should_not raise_error
   end
 
   it "should permit for key overrides" do
@@ -58,7 +93,7 @@ describe "Keys" do
       key :class, String, :accessors => :skip
     end
 
-    doc.collection.insert('class' => 'String')
+    doc.collection.insert_one('class' => 'String')
     doc.all.first.tap do |d|
       d.class.should == doc
       d["class"].should == "String"
@@ -74,7 +109,7 @@ describe "Keys" do
     }
 
     before do
-      doc.collection.insert(:dynamic => "foo")
+      doc.collection.insert_one(:dynamic => "foo")
       doc.first
     end
 
@@ -106,7 +141,7 @@ describe "Keys" do
       doc.class_eval do
         key :NotConstant
       end
-      doc.collection.insert("NotConstant" => "Just data!")
+      doc.collection.insert_one("NotConstant" => "Just data!")
       doc.first.notConstant.should == "Just data!"
     end
 
@@ -116,7 +151,16 @@ describe "Keys" do
       doc.class_eval do
         key :"bad-name", :__dynamic => true
       end
-      expect { doc.new.method(:"bad-name") }.to raise_error(NameError)
+      lambda { doc.new.method(:"bad-name") }.should raise_error(NameError)
+    end
+
+    it "should not create accessors for reserved keys" do
+      doc = Doc {}
+      doc.should_not_receive(:create_accessors_for)
+      doc.class_eval do
+        key :"class", :__dynamic => true
+      end
+      doc.new.class.should == doc
     end
 
     it "should create accessors for good keys" do
@@ -124,13 +168,13 @@ describe "Keys" do
         key :good_name
       }
       doc.new.good_name.should be_nil
-      expect { doc.new.method("good_name") }.to_not raise_error
+      lambda { doc.new.method("good_name") }.should_not raise_error
     end
   end
 
   it "should handle loading dynamic fields from the database that have bad names" do
     doc = Doc {}
-    doc.collection.insert("foo-bar" => "baz-bin")
+    doc.collection.insert_one("foo-bar" => "baz-bin")
 
     doc.first["foo-bar"].should == "baz-bin"
   end
@@ -151,7 +195,7 @@ describe "Keys" do
       end
 
       it "should serialize with aliased keys" do
-        AliasedKeyModel.collection.find_one.keys.should =~ %w(_id f bar)
+        AliasedKeyModel.collection.find.first.keys.should =~ %w(_id f bar)
 
         AliasedKeyModel.first.tap do |d|
           d.foo.should == "whee!"
@@ -159,8 +203,35 @@ describe "Keys" do
         end
       end
 
-      it "should permit querying via aliases" do
-        AliasedKeyModel.where(AliasedKeyModel.abbr(:f) => "whee!").first.foo.should == "whee!"
+      it "should permit querying via direct field names" do
+        AliasedKeyModel.where(AliasedKeyModel.abbr(:foo) => "whee!").first.foo.should == "whee!"
+      end
+
+      it "should permit querying via direct field names" do
+        AliasedKeyModel.where(:foo => "whee!").criteria_hash.keys.should == ["f"]
+        AliasedKeyModel.where(:foo => "whee!").first.foo.should == "whee!"
+      end
+
+      it "should permit filtering via aliases" do
+        AliasedKeyModel.where(:foo => "whee!").fields(:foo).first.foo.should == "whee!"
+      end
+
+      it "should permit dealiasing of atomic operations" do
+        m = AliasedKeyModel.first
+        m.set(:foo => 1)
+        AliasedKeyModel.collection.find.first["f"].should == 1
+        AliasedKeyModel.collection.find.first["foo"].should be_nil
+      end
+
+      it "should permit dealiasing of update operations" do
+        m = AliasedKeyModel.first
+        m.update_attributes(:foo => 1)
+        AliasedKeyModel.collection.find.first["f"].should == 1
+        AliasedKeyModel.collection.find.first["foo"].should be_nil
+      end
+
+      it "should not break when unaliasing non-keys" do
+        AliasedKeyModel.where(:badkey => "whee!").criteria_hash.keys.should == [:badkey]
       end
 
       it "should serialize to JSON with full keys" do
@@ -175,7 +246,7 @@ describe "Keys" do
       before { AliasedKeyModel.create(:with_underscores => "foobar") }
       it "should work" do
         AliasedKeyModel.first.with_underscores.should == "foobar"
-        AliasedKeyModel.collection.find_one["with-hyphens"].should == "foobar"
+        AliasedKeyModel.collection.find.first["with-hyphens"].should == "foobar"
       end
     end
 
@@ -183,7 +254,7 @@ describe "Keys" do
       before { AliasedKeyModel.create(:field_name => "foobar") }
       it "should work" do
         AliasedKeyModel.first.field_name.should == "foobar"
-        AliasedKeyModel.collection.find_one["alternate_field_name"].should == "foobar"
+        AliasedKeyModel.collection.find.first["alternate_field_name"].should == "foobar"
       end
     end
 
@@ -220,7 +291,7 @@ describe "Keys" do
         owner.reload
         owner.associated_documents.to_a.should =~ associated_documents.to_a
 
-        AssociatedKeyWithAlias.collection.find_one.keys.should =~ %w(_id n aid)
+        AssociatedKeyWithAlias.collection.find.first.keys.should =~ %w(_id n aid)
       end
 
       it "should work with embedded documents" do
@@ -230,8 +301,39 @@ describe "Keys" do
 
         owner.reload
         owner.other_documents[0].embedded_name.should == "Underling"
-        owner.collection.find_one["other_documents"][0]["en"].should == "Underling"
+        owner.collection.find.first["other_documents"][0]["en"].should == "Underling"
       end
     end
   end
+
+  describe "removing keys" do
+    DocWithRemovedKey = Doc do
+      key :something
+      validates_uniqueness_of :something
+      remove_key :something
+    end
+
+    it 'should remove the key' do
+      DocWithRemovedKey.keys.should_not have_key "_something"
+    end
+
+    it 'should remove validations' do
+      DocWithRemovedKey._validate_callbacks.should be_empty
+    end
+  end
+
+  describe "removing keys in the presence of a validation method" do
+    DocWithRemovedValidator = Doc do
+      key :something
+      validate :something_valid?
+      remove_key :something
+
+      def something_valid?; true; end
+    end
+
+    it 'should remove the key' do
+      DocWithRemovedKey.keys.should_not have_key "_something"
+    end
+
+  end
 end