dm-mongo-adapter 0.2.0.pre1

data/spec/legacy/embedments_spec.rb

@@ -0,0 +1,177 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe DataMapper::Mongo::Model::Embedment do
+  before :all do
+    # let's start with an empty collection
+    $db.drop_collection('users')
+
+    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_attributes = {:name => 'piotr', :age => 26, :address => {:street => '1st ave', :post_code => '123-45'}}
+  end
+
+  describe "Resource" do
+    # @done
+    it "should respond to #embeds" do
+      User.should respond_to(:embeds)
+    end
+
+    it "should respond to #embedded_in" do
+      User.should respond_to(:embedded_in)
+    end
+
+    # @done
+    it "should respond to #embedments" do
+      User.should respond_to(:embedments)
+    end
+  end
+
+  describe "#embeds" do
+    describe "One-To-One Relationship" do
+      before :all do
+        User.embeds(1, :address, :model => Address)
+      end
+
+      describe "#dirty?" do
+        # @done
+        it "should return false without dirty attributes and without an embedded resource" do
+          u = User.new
+          u.dirty?.should be_false
+        end
+
+        # @done
+        it "should return true with a dirty attributes and with an embedded resource" do
+          u = User.new(@user_attributes.except(:address))
+          u.dirty?.should be_true
+        end
+      end
+
+      # @done
+      it "should create a new embedment" do
+        User.embedments[:address].class.should be(Embedments::OneToOne::Relationship)
+      end
+
+      # @done
+      it "should create readers and writers for the embedded resource" do
+        user = User.new
+
+        user.should respond_to("address")
+        user.should respond_to("address=")
+      end
+
+      # @done
+      it "should not require embedded resource to save the parent" do
+        user = User.new(@user_attributes.except(:address))
+        user.save.should be_true
+      end
+
+      # @done
+      it "should set the embedded resource" do
+        user = User.new
+        address = Address.new
+
+        user.address = address
+        user.address.should be(address)
+
+        address.parent.should be(user)
+      end
+
+      # @done
+      it "should save the embedded resource" do
+        user = User.new(@user_attributes)
+        user.save.should be(true)
+        user.address.new?.should be(false)
+      end
+
+      # @done
+      it "should load parent and the embedded resource" do
+        _id = $db.collection('users').insert(@user_attributes)
+
+        user = User.get(_id)
+
+        user.address.should_not be_nil
+      end
+
+      # @done
+      #
+      # Spec now fails since a OneToOne relationship which hasn't been set
+      # should return nil.
+      #
+      # it "should load parent if the embedded resource is nil" do
+      #   _id = $db.collection('users').insert(:name => 'john')
+      #
+      #   user = User.get(_id)
+      #   user.address.should_not be_nil
+      # end
+    end
+
+    describe "One-to-Many Relationship" do
+      before :all do
+        User.embeds User.n, :cars
+      end
+
+      it "should create a new embedment" do
+        User.embedments[:cars].class.should be(Embedments::OneToMany::Relationship)
+      end
+
+      it "should create readers and writers for the embedded resource" do
+        user = User.new
+
+        user.should respond_to("cars")
+        user.should respond_to("cars=")
+      end
+
+      it "should set the embedded collection" do
+        user = User.new
+
+        3.times { user.cars << Car.new }
+
+        user.cars.size.should eql(3)
+        user.cars.all?{ |c| c.parent == user }.should be(true)
+      end
+
+      it "should save the embedded resources" do
+        user = User.new @user_attributes.except(:address)
+
+        ['ford', 'honda', 'volvo'].each { |name| user.cars << Car.new(:name => name) }
+
+        user.save.should be(true)
+        user.cars.all? { |car| car.saved? }.should be(true)
+      end
+
+      it "should load parent with its embedded collection" do
+        _id = $db.collection('users').insert(
+          "name"=>"piotr", "cars"=>[{"name"=>"ford"}, {"name"=>"honda"}, {"name"=>"volvo"}], "age"=>26)
+
+        user = User.get(_id)
+
+        user.cars.should_not be_nil
+        user.cars.size.should eql(3)
+      end
+    end
+
+    describe "Many-To-One Relationship" do
+      it "should be implemented"
+    end
+  end
+end

data/spec/legacy/modifier_spec.rb

@@ -0,0 +1,81 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+# @done
+describe "updates with mongodb modifiers" do
+  # @done
+  before :all do
+    $db.drop_collection("posts")
+    class ::Post
+      include DataMapper::Mongo::Resource
+      property :id, ObjectID
+      property :comment_count, Integer
+      property :body, Text
+    end
+  end
+
+  # @done
+  it "should increment" do
+    post = Post.create(:comment_count => 1)
+    post.increment(:comment_count, 1)
+    post.comment_count.should == 2
+    Post.get(post.id).comment_count.should == 2
+  end
+
+  # @done
+  it "should decrement" do
+    post = Post.create(:comment_count => 10)
+    post.decrement(:comment_count, 5)
+    post.comment_count.should == 5
+    Post.get(post.id).comment_count.should == 5
+  end
+
+  # @done
+  it "should set" do
+#    post = Post.create(:body => "This needs to be edited", :comment_count => 2)
+#    post.set(:body => "This was edited", :comment_count => 3)
+#    post.body.should == "This was edited"
+#    post.comment_count.should == 3
+#    fresh_post = Post.get(post.id)
+#    fresh_post.body.should == "This was edited"
+#    fresh_post.comment_count.should == 3
+    pending
+  end
+
+  # @done
+  it "should unset" do
+    #post = Post.create(:body => "This needs to be removed", :comment_count => 2)
+    #post.unset(:body, :comment_count)
+    #post.body.should be_nil
+    #post.comment_count.should be_nil
+    #fresh_post = Post.get(post.id)
+    #fresh_post.body.should be_nil
+    #fresh_post.comment_count.should be_nil
+    pending
+  end
+
+  # @done
+  it "should push" do
+    pending
+  end
+
+  # @done
+  it "should push_all" do
+    pending
+  end
+
+  # @done
+  it "should pop" do
+    pending
+  end
+
+  # @done
+  it "should pull" do
+    pending
+  end
+
+  # @done
+  it "should pull_all" do
+    pending
+  end
+
+end

data/spec/legacy/property_spec.rb

@@ -0,0 +1,51 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe "Property" do
+  before :all do
+    ENV['TZ'] = 'UTC'
+
+    class ::User
+      include DataMapper::Mongo::Resource
+
+      property :id, ObjectID
+      property :date_time_field, DateTime
+      property :date_field, Date
+      property :type, Discriminator
+    end
+  end
+
+  describe "Class" do
+    it "should be typecasted to a string" do
+      lambda{
+        user = User.create!(:type => User)
+      }.should_not raise_error
+    end
+  end
+
+  describe "DateTime" do
+    it "should be typecasted from a Time object" do
+      dt_now = DateTime.now
+      t_now  = Time.now
+
+      _id = $db.collection('users').insert(:type => 'User', :date_time_field => t_now)
+
+      user = User.get(_id)
+
+      user.date_time_field.class.should be(DateTime)
+      user.date_time_field.to_time.to_i.should == dt_now.to_time.to_i
+    end
+  end
+
+  describe "Date" do
+    it "should be typecasted from a Time object" do
+      today = Date.today
+
+      _id = $db.collection('users').insert(:type => 'User', :date_field => Time.parse(today.to_s))
+
+      user = User.get(_id)
+      
+      user.date_field.class.should be(Date)
+      Time.parse(user.date_field.to_s).should == Time.parse(today.to_s)
+    end
+  end
+end

data/spec/legacy/spec_helper.rb

@@ -0,0 +1,3 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+$db = DataMapper::Mongo::Spec.database(:default)
+include DataMapper::Mongo

data/spec/legacy/sti_spec.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+# @done (in public/types/discriminator_spec.rb which is a modified copy from dm-core specs)
+describe "Single Table Inheritance" do
+  before(:all) do
+    class ::Person
+      include DataMapper::Mongo::Resource
+
+      property :id, ObjectID
+      property :name, String
+      property :job, String
+      property :type, Discriminator
+    end
+
+    class ::Male < Person; end
+    class ::Father < Male; end
+    class ::Son < Male; end
+  end
+
+  before(:each) do
+    $db.drop_collection('people')
+  end
+
+  it "should have a type property that reflects the class" do
+    [Person, Male, Father, Son].each_with_index do |model, i|
+      object = model.create!(:name => "#{model} #{i}")
+      object.reload
+      object.type.should == model
+    end
+  end
+
+  it "should parent should return an instance of the child when type is explicitly specified" do
+    [Person, Male, Father, Son].each_with_index do |model, i|
+      object = model.create!(:name => "#{model} #{i}")
+      object.reload
+      object.should be_instance_of(model)
+    end
+  end
+
+  it "should discriminate types during reads" do
+    father1 = Father.create!(:name => '1')
+    father2 = Father.create!(:name => '2')
+
+    fathers = Father.all
+
+    fathers.should == [father1, father2]
+
+    fathers.each do |father|
+      father.type.should be(Father)
+      father.should be_instance_of(Father)
+    end
+  end
+end

data/spec/lib/cleanup_models.rb

@@ -0,0 +1,32 @@
+module DataMapper::Mongo::Spec
+  module CleanupModels
+
+    # Cleans up models after a spec by dropping the Mongo collection,
+    # removing the model classes from the descendants list, and then
+    # undefining the constants.
+    #
+    # @todo Only used once; try to remove.
+    #
+    def cleanup_models(*models)
+      unless models.empty?
+        model = models.pop
+        sym   = model.to_s.to_sym
+
+        if Object.const_defined?(sym)
+          if model.respond_to?(:storage_name)
+            db = DataMapper::Mongo::Spec.database(model.repository.name)
+            db.drop_collection(model.storage_name)
+          end
+
+          DataMapper::Model.descendants.delete(model)
+          DataMapper::Mongo::EmbeddedModel.descendants.delete(model)
+
+          Object.send(:remove_const, sym)
+        end
+
+        cleanup_models(*models)
+      end
+    end
+
+  end # CleanupModels
+end # DataMaper::Mongo::Spec

data/spec/lib/raw_connections.rb

@@ -0,0 +1,11 @@
+module DataMapper::Mongo::Spec
+  module RawConnections
+    # Returns a Mongo::Database instance which can be used for manually
+    # adjusting the database used by repository +repo+.
+    def database(repo = :default)
+      DataMapper.repository(repo).adapter.send(:database)
+    end
+  end
+
+  extend RawConnections
+end

data/spec/public/embedded_collection_spec.rb

@@ -0,0 +1,61 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe DataMapper::Mongo::EmbeddedResource do
+  before :all do
+    class ::Student
+      include DataMapper::Mongo::Resource
+      property :id,   ObjectID
+      property :name, String
+
+      embeds n, :scores
+    end
+
+    class ::Score
+      include DataMapper::Mongo::EmbeddedResource
+      property :value,  Float
+      property :course, String
+    end
+
+    Student.all.destroy!
+
+    @student = Student.new
+  end
+
+  describe "#new" do
+    it "should create a new instance and add it to the collection" do
+      score = @student.scores.new
+      score.should be_kind_of(Score)
+      score.parent.should be(@student)
+    end
+
+    it "should set a new instance with attributes" do
+      attrs = { :value => 5.0, :course => 'MongoDB' }
+      score = @student.scores.new(attrs)
+      score.attributes.should == attrs
+    end
+  end
+
+  describe "#dirty?" do
+    it "should return true when includes dirty resources" do
+      @student.scores << Score.new(:value => 6.0)
+      @student.scores.dirty?.should be(true)
+    end
+
+    it "should return false when it doesn't include dirty resources" do
+      @student.scores << Score.new
+      @student.scores.dirty?.should be(true)
+    end
+  end
+
+  describe "#save" do
+    it "should call save on parent" do
+      expected = Score.new(:value => 7.0)
+
+      @student.scores << expected
+      @student.scores.save.should be(true)
+      @student.clean?.should be(true)
+      
+      @student.reload.scores.should == [expected]
+    end
+  end
+end