dm-mongo-adapter 0.2.0.pre1

data/spec/legacy/adapter_spec.rb

@@ -0,0 +1,174 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'adapter_shared_spec'))
+
+describe DataMapper::Adapters::MongoAdapter do
+  before :all do
+    # let's start with an empty collection
+    $db.drop_collection('heffalumps')
+
+    class ::Heffalump
+      include DataMapper::Mongo::Resource
+
+      property :id,        ObjectID
+      property :color,     String
+      property :num_spots, Integer
+      property :striped,   Boolean
+    end
+  end
+
+  it_should_behave_like "An Adapter"
+
+  describe "authentication" do
+    before(:all) do
+      # Create a user if needed.
+      @details = { :username => 'dm-mongo-auth',
+                   :password => 'dm-mongo-password' }
+
+      connection = Mongo::Connection.new
+
+      begin
+        users = connection.db('dm-mongo-test-auth').collection('system.users')
+
+        # Remove the existing user if one is present.
+        users.remove(:user => @details[:username])
+        users.remove(:username => @details[:username])
+
+        # Create a new user.
+        users.save(
+          :user => @details[:username],
+          :pwd  => Digest::MD5.hexdigest(
+            "#{@details[:username]}:mongo:#{@details[:password]}")
+        )
+      ensure
+        connection.close
+      end
+    end
+
+    it 'should raise no error when connecting with valid credentials' do
+      DataMapper.setup(:dm_mongo_auth,
+        :adapter  => 'mongo',
+        :hostname => 'localhost',
+        :database => 'dm-mongo-test-auth',
+        :username => @details[:username],
+        :password => @details[:password]
+      )
+
+      lambda do
+        repository(:dm_mongo_auth) do
+          Heffalump.create(:color => 'red', :num_spots => 2)
+        end
+      end.should_not raise_error(DataMapper::Mongo::Adapter::ConnectionError)
+    end
+
+    it 'should raise an error when connecting with an invalid username' do
+      DataMapper.setup(:dm_mongo_auth,
+        :adapter  => 'mongo',
+        :hostname => 'localhost',
+        :database => 'dm-mongo-test',
+        :username => @details[:username],
+        :password => '__invalid__'
+      )
+
+      lambda do
+        repository(:dm_mongo_auth) do
+          Heffalump.create(:color => 'red', :num_spots => 2)
+        end
+      end.should raise_error(DataMapper::Mongo::Adapter::ConnectionError)
+    end
+
+    it 'should raise an error when connecting with an invalid password' do
+      DataMapper.setup(:dm_mongo_auth,
+        :adapter  => 'mongo',
+        :hostname => 'localhost',
+        :database => 'dm-mongo-test',
+        :username => '__invalid__',
+        :password => @details[:password]
+      )
+
+      lambda do
+        repository(:dm_mongo_auth) do
+          Heffalump.create(:color => 'red', :num_spots => 2)
+        end
+      end.should raise_error(DataMapper::Mongo::Adapter::ConnectionError)
+    end
+  end
+
+  describe "queries" do
+    before :all do
+      @red   = Heffalump.create(:color => 'red', :num_spots => 2)
+      @green = Heffalump.create(:color => 'green', :num_spots => 3)
+      @blue  = Heffalump.create(:color => 'blue', :num_spots => 5)
+    end
+
+    it "should be able to search for objects matching conditions for the same property" do
+      col = Heffalump.all(:num_spots.gt => 2, :num_spots.not => 3)
+
+      col.size.should == 1
+      col.first.should eql(@blue)
+    end
+  end
+
+  describe "embedded objects as properties" do
+    before :all do
+      class ::Zoo
+        include DataMapper::Mongo::Resource
+
+        property :id, ObjectID
+        property :animals, EmbeddedArray
+        property :address, EmbeddedHash
+      end
+    end
+
+    describe "using arrays" do
+      it "should save a resource" do
+        zoo = Zoo.new
+        zoo.animals = [:marty, :alex, :gloria]
+
+        lambda {
+          zoo.save
+        }.should_not raise_error
+      end
+
+      it "should be able to search with 'equal to' criterium" do
+        penguins = [:skipper, :kowalski, :private, :rico]
+        Zoo.create(:animals => penguins)
+
+        zoo = Zoo.first(:animals => penguins)
+        zoo.should_not be_nil
+        zoo.animals.should eql(penguins)
+      end
+    end
+
+    describe "using hashes" do
+      it "should save a resource" do
+        zoo = Zoo.new
+        zoo.address = {:street => 'Street 1', :telephone => '123-45-67'}
+
+        lambda {
+          zoo.save
+          zoo.address.class.should be(Hash)
+        }.should_not raise_error
+      end
+
+      it "should set the property value as hash" do
+        _id = $db.collection('zoos').insert(:address => { :street => 'Street 2' })
+
+        zoo = Zoo.get(_id)
+
+        zoo.address.should be_kind_of(Hash)
+        zoo.address[:street].should eql('Street 2')
+      end
+
+      it "should be able to search with 'equal to' criterium" do
+        address = {:street => 'Street 3'}
+
+        Zoo.create(:address => address)
+
+        zoo = Zoo.first(:address => address)
+
+        zoo.should_not be_nil
+        zoo.address.should == address
+      end
+    end
+  end
+end

data/spec/legacy/associations_spec.rb

@@ -0,0 +1,140 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe "associations" do
+  before :all do
+    cleanup_models :User, :Group
+
+    class ::User
+      include DataMapper::Mongo::Resource
+
+      property :id, ObjectID
+      property :group_id, DBRef
+      property :name, String
+      property :age, Integer
+    end
+
+    class ::Group
+      include DataMapper::Mongo::Resource
+
+      property :id, ObjectID
+      property :name, String
+    end
+
+    class ::Friend
+      include DataMapper::Mongo::Resource
+
+      property :id, ObjectID
+      property :name, String
+    end
+
+    User.belongs_to :group
+    Group.has Group.n, :users
+    User.has User.n, :friends
+  end
+
+  before :each do
+    $db.drop_collection('users')
+    $db.drop_collection('groups')
+  end
+
+  describe "belongs_to" do
+    before do
+      @john = User.create(:name => 'john', :age => 101)
+      @jane = User.create(:name => 'jane', :age => 102)
+
+      @group = Group.create(:name => 'dm hackers')
+    end
+
+    it "should set parent object _id in the db ref" do
+      lambda {
+        @john.group = @group
+        @john.save
+      }.should_not raise_error
+
+      @john.group_id.should eql(@group.id)
+    end
+
+    it "should fetch parent object" do
+      user = User.create(:name => 'jane')
+      user.group_id = @group.id
+      user.group.should eql(@group)
+    end
+
+    it "should work with SEL" do
+      users = User.all(:name => /john|jane/)
+
+      users.each { |u| u.update(:group_id => @group.id) }
+
+      users.each do |user|
+        user.group.should_not be_nil
+      end
+    end
+  end
+
+  describe "has many" do
+    before :each do
+      @john = User.create(:name => 'john', :age => 101)
+      @jane = User.create(:name => 'jane', :age => 102)
+
+      @group = Group.create(:name => 'dm hackers')
+
+      [@john, @jane].each { |user| user.update(:group_id => @group.id) }
+    end
+
+    # @done
+    it "should get children" do
+      @group.users.size.should eql(2)
+    end
+
+    it "should add new children with <<" do
+      user = User.new(:name => 'kyle')
+      @group.users << user
+      user.group_id.should eql(@group.id)
+      @group.users.size.should eql(3)
+    end
+
+    # @done
+    it "should replace children" do
+      user = User.create(:name => 'stan')
+      @group.users = [user]
+      @group.users.size.should eql(1)
+      @group.users.first.should eql(user)
+    end
+
+    it "should fetch children matching conditions" do
+      users = @group.users.all(:name => 'john')
+      users.size.should eql(1)
+    end
+  end
+
+  describe "nested saves" do
+    before :each do
+      #@friend1 = Friend.new
+      #@friend2 = Friend.new
+      @user1 = User.new
+      @user2 = User.new
+      @group = Group.new(:users =>
+                         [
+                          {:friends =>
+                            [{:name => "blah"}, {:name => "blah2"}]
+                          },
+                          {:friends =>
+                            [{:name => "blah3"},{:name => "blah4"}]
+                          }])
+    end
+
+    # @done
+    it "should save nested objects" do
+
+      #@group.users << @user1
+      #@group.users << @user2
+      @group.save
+      Group.get(@group.id).users.all.each do |u|
+        u.group_id.should == @group.id
+        u.friends.each do |f|
+          f.user_id.should == u.id
+        end
+      end
+    end
+  end
+end

data/spec/legacy/embedded_resource_spec.rb

@@ -0,0 +1,157 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe DataMapper::Mongo::EmbeddedModel do
+
+  before(:all) do
+    class ::User
+      include Resource
+
+      property :id,   ObjectID
+      property :name, String
+      property :age,  Integer
+    end
+
+    class ::Address
+      include EmbeddedResource
+
+      property :street,    String
+      property :post_code, String
+      property :phone,     String
+    end
+
+    class ::Car
+      include EmbeddedResource
+
+      property :name, String
+    end
+
+    User.embeds 1, :address, :model => Address
+    User.has User.n, :cars
+  end
+
+  describe "#new" do
+    it "should not need a key" do
+      lambda {
+        class ::Thing
+          include DataMapper::Mongo::EmbeddedResource
+          property :name, String
+        end
+
+        Thing.new
+      }.should_not raise_error
+    end
+  end
+
+  # @done
+  describe "creating new resources" do
+    # @done
+    it "should save via parent" do
+      user = User.new :address => Address.new(:street => 'Blank 0')
+      user.save.should be(true)
+      user.new?.should be(false)
+    end
+
+    # @done
+    it "should create via parent" do
+      user = User.create(:address => Address.new(:street => 'Blank 0'))
+      user.new?.should be(false)
+    end
+
+    # @done
+    it "should save an embedded resource" do
+      user = User.new :address => Address.new(:street => 'Blank 0')
+      user.address.save.should be(true)
+      user.new?.should be(false)
+      user.address.new?.should be(false)
+    end
+
+    # @done
+    it "should not allow to create an embedded resource without a parent" do
+      address = Address.new(:street => 'Blank 0')
+      lambda { address.save }.should raise_error(EmbeddedResource::MissingParentError)
+    end
+  end
+
+  # @done
+  describe "updating resources" do
+    before :all do
+      @user = User.create(:name => 'john', :address => Address.new)
+    end
+
+    # @done
+    it "should update embedded resource" do
+      @user.update(:address => { :street => 'Something 1' }).should be(true)
+
+      @user.reload
+
+      @user.address.street.should_not be_nil
+      @user.address.street.should eql('Something 1')
+    end
+  end
+
+  describe "#dirty?" do
+    before :all do
+      @user = User.new
+    end
+
+    # @done
+    it "should return false when new" do
+      address = Address.new
+      address.dirty?.should be(false)
+    end
+
+    # @done
+    it "should return true if changed" do
+      address = Address.new(:street => "Some Street 1234")
+      address.dirty?.should be(true)
+    end
+
+    # @done
+    it "should return false for a clean parent" do
+      @user.dirty?.should be(false)
+    end
+
+    # @done
+    it "should return true with one-to-one" do
+      @user.address = Address.new(:street => 'Some Street 1234')
+      @user.dirty?.should be(true)
+      @user.address.dirty?.should be(true)
+    end
+
+    it "should include embedded resource attributes in the dirty attributes list" do
+      @user.address = Address.new
+      @user.address.street = 'Some Street 1234'
+
+      dirty_attributes    = @user.dirty_attributes
+
+      dirty_attributes.should_not be_nil
+
+      address_dirty_attrs = dirty_attributes[@user.model.embedments[:address]]
+
+      address_dirty_attrs.should_not be_nil
+      address_dirty_attrs.keys.size.should eql(1)
+      address_dirty_attrs.values.include?('Some Street 1234').should be(true)
+    end
+
+    describe "with saved resource" do
+      before :all do
+        @user.name = 'john'
+        @user.address = Address.new(:street => 'A Street 101')
+        @user.save
+      end
+
+      # @done
+      it "should return true with one-to-many" do
+        @user.cars << Car.new
+        @user.dirty?.should be(true)
+      end
+
+      # @done
+      it "should return false with a loaded resource" do
+        user = User.get(@user.id)
+        user.dirty_embedments?.should be(false)
+        user.dirty?.should be(false)
+      end
+    end
+  end
+end