mongoid-locomotive 2.0.0.beta9

data/spec/models/pet.rb

@@ -0,0 +1,7 @@
+class Pet
+  include Mongoid::Document
+  field :name
+  field :weight, :type => Float, :default => 0.0
+  embeds_many :vet_visits
+  embedded_in :pet_owner, :inverse_of => :pet
+end

data/spec/models/pet_owner.rb

@@ -0,0 +1,6 @@
+class PetOwner
+  include Mongoid::Document
+  field :title
+  embeds_one :pet
+  embeds_one :address
+end

data/spec/models/phone.rb

@@ -0,0 +1,7 @@
+class Phone
+  include Mongoid::Document
+  field :number
+  key :number
+  embeds_one :country_code
+  embedded_in :person, :inverse_of => :phone_numbers
+end

data/spec/models/post.rb

@@ -0,0 +1,25 @@
+class Tag
+  include Mongoid::Document
+  field :text
+  referenced_in :post, :stored_as => :array
+end
+
+class Post
+  include Mongoid::Document
+  include Mongoid::Versioning
+  include Mongoid::Timestamps
+  field :title
+  referenced_in :person
+  referenced_in :author, :foreign_key => :author_id, :class_name => "User"
+  referenced_in :poster, :foreign_key => :poster_id, :class_name => "Agent"
+
+  references_many :tags, :stored_as => :array
+
+  named_scope :recent, where(:created_at => { "$lt" => Time.now, "$gt" => 30.days.ago })
+
+  class << self
+    def old
+      where(:created_at => { "$lt" => 30.days.ago })
+    end
+  end
+end

data/spec/models/preference.rb

@@ -0,0 +1,7 @@
+class Preference
+  include Mongoid::Document
+  field :name
+  field :value
+  references_many :people, :stored_as => :array, :inverse_of => :preferences
+  validates_length_of :name, :minimum => 2, :allow_nil => true
+end

data/spec/models/question.rb

@@ -0,0 +1,8 @@
+class Question
+  include Mongoid::Document
+  field :content
+  embedded_in :survey, :inverse_of => :questions
+  embeds_many :answers
+  
+  accepts_nested_attributes_for :answers, :reject_if => lambda { |a| a[:content].blank? }, :allow_destroy => true
+end

data/spec/models/survey.rb

@@ -0,0 +1,6 @@
+class Survey
+  include Mongoid::Document
+  embeds_many :questions
+
+  accepts_nested_attributes_for :questions, :reject_if => lambda{ |a| a[:content].blank? }, :allow_destroy => true
+end

data/spec/models/translation.rb

@@ -0,0 +1,5 @@
+class Translation
+  include Mongoid::Document
+  field :language
+  embedded_in :name, :inverse_of => :translations
+end

data/spec/models/user.rb

@@ -0,0 +1,6 @@
+class User
+  include Mongoid::Document
+  references_one :account, :foreign_key => :creator_id
+  references_many :posts, :foreign_key => :author_id, :inverse_of => :author
+  field :name
+end

data/spec/models/user_accout.rb

@@ -0,0 +1,5 @@
+class UserAccount
+  include Mongoid::Document
+  field :username
+  validates_uniqueness_of :username, :message => "is not unique"
+end

data/spec/models/vet_visit.rb

@@ -0,0 +1,5 @@
+class VetVisit
+  include Mongoid::Document
+  field :date, :type => Date
+  embedded_in :pet, :inverse_of => :vet_visits
+end

data/spec/models/video.rb

@@ -0,0 +1,5 @@
+class Video
+  include Mongoid::Document
+  field :title
+  embedded_in :person, :inverse_of => :videos
+end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+MODELS = File.join(File.dirname(__FILE__), "models")
+$LOAD_PATH.unshift(MODELS)
+
+require 'rubygems'
+
+gem "mocha", ">= 0.9.8"
+
+require "mongoid"
+require "mocha"
+require "rspec"
+
+Mongoid.configure do |config|
+  name = "mongoid_test"
+  host = "localhost"
+  config.master = Mongo::Connection.new.db(name)
+  config.logger = nil
+  # config.slaves = [
+    # Mongo::Connection.new(host, 27018, :slave_ok => true).db(name)
+  # ]
+end
+
+Dir[ File.join(MODELS, "*.rb") ].sort.each { |file| require File.basename(file) }
+
+Rspec.configure do |config|
+  config.mock_with :mocha
+  config.after :suite do
+    Mongoid.master.collections.select {|c| c.name !~ /system/ }.each(&:drop)
+  end
+end
+

data/spec/unit/mongoid/associations/embedded_in_spec.rb

@@ -0,0 +1,193 @@
+require "spec_helper"
+
+describe Mongoid::Associations::EmbeddedIn do
+
+  let(:child) do
+    Name.new(:first_name => "Drexel", :last_name => "Spivey")
+  end
+
+  let(:target) do
+    Person.new(:title => "Pimp")
+  end
+
+  let(:options) do
+    Mongoid::Associations::Options.new(:name => :person, :inverse_of => :name)
+  end
+
+  let(:has_many_options) do
+    Mongoid::Associations::Options.new(:name => :person, :inverse_of => :addresses)
+  end
+
+  describe "#find" do
+
+    before do
+      @association = Mongoid::Associations::EmbeddedIn.new(target, options)
+    end
+
+    context "when finding by id" do
+
+      it "always returns the target document" do
+        @association.find("").should == target
+      end
+
+    end
+
+  end
+
+  describe "#initialize" do
+
+    before do
+      @association = Mongoid::Associations::EmbeddedIn.new(target, options)
+    end
+
+    it "sets the target" do
+      @association.target.should == target
+    end
+
+    it "sets the options" do
+      @association.options.should == options
+    end
+
+  end
+
+  describe "#initialize" do
+
+    before do
+      @parent = Person.new(:title => "Dr")
+      @name = Name.new(:first_name => "Richard", :last_name => "Dawkins")
+      @parent.name = @name
+      @block = Proc.new {
+        def extension
+          "Testing"
+        end
+      }
+      @options = Mongoid::Associations::Options.new(:name => :person, :extend => @block)
+      @association = Mongoid::Associations::EmbeddedIn.new(@parent, @options)
+    end
+
+    context "when the options have an extension" do
+
+      it "adds the extension module" do
+        @association.extension.should == "Testing"
+      end
+
+    end
+
+  end
+
+  describe ".instantiate" do
+
+    context "when parent exists" do
+
+      before do
+        @parent = stub
+        @target = stub(:_parent => @parent)
+        @association = Mongoid::Associations::EmbeddedIn.instantiate(@target, options)
+      end
+
+      it "sets the parent to the target" do
+        @association.target.should == @parent
+      end
+
+    end
+
+    context "when parent is nil" do
+
+      before do
+        @document = stub(:_parent => nil)
+      end
+
+      it "returns nil" do
+        Mongoid::Associations::EmbeddedIn.instantiate(@document, options).should be_nil
+      end
+
+    end
+
+  end
+
+  describe ".macro" do
+
+    it "returns :embedded_in" do
+      Mongoid::Associations::EmbeddedIn.macro.should == :embedded_in
+    end
+
+  end
+
+  describe "#method_missing" do
+
+    before do
+      @association = Mongoid::Associations::EmbeddedIn.new(target, options)
+    end
+
+    context "when method is a getter" do
+
+      it "delegates to the target" do
+        @association.title.should == "Pimp"
+      end
+
+    end
+
+    context "when method is a setter" do
+
+      before do
+        @association.title = "Dealer"
+      end
+
+      it "delegates to the target" do
+        @association.title.should == "Dealer"
+      end
+
+    end
+
+    context "when method does not exist" do
+
+      it "raises an error" do
+        lambda { @association.nothing }.should raise_error(NoMethodError)
+      end
+
+    end
+
+  end
+
+  describe ".update" do
+
+    context "when child is a has one" do
+
+      before do
+        @name = Name.new(:first_name => "Test", :last_name => "User")
+        @person = Person.new(:title => "Mrs")
+        @association = Mongoid::Associations::EmbeddedIn.update(@person, @name, options)
+      end
+
+      it "updates the parent document" do
+        @person.name.should == @name
+      end
+
+      it "updates the parent attributes" do
+        @person.attributes[:name].except(:_id).should ==
+          { "first_name" => "Test", "last_name" => "User" }
+      end
+
+      it "returns the proxy association" do
+        @association.target.should == @person
+      end
+
+    end
+
+    context "when child is a has many" do
+
+      before do
+        @address = Address.new(:street => "Broadway")
+        @person = Person.new(:title => "Mrs")
+        Mongoid::Associations::EmbeddedIn.update(@person, @address, has_many_options)
+      end
+
+      it "updates the parent document" do
+        @person.addresses.first.should == @address
+      end
+
+    end
+
+  end
+
+end

data/spec/unit/mongoid/associations/embeds_many_spec.rb

@@ -0,0 +1,626 @@
+require "spec_helper"
+
+describe Mongoid::Associations::EmbedsMany do
+
+  before do
+    @attributes = { "addresses" => [
+      { "_id" => "street-1", "street" => "Street 1", "state" => "CA" },
+      { "_id" => "street-2", "street" => "Street 2" } ] }
+    @document = stub(:raw_attributes => @attributes, :add_observer => true, :observe => true, :update_child => nil)
+  end
+
+  describe "#[]" do
+
+    before do
+      @association = Mongoid::Associations::EmbedsMany.new(
+        @document,
+        Mongoid::Associations::Options.new(:name => :addresses)
+      )
+    end
+
+    context "when the index is present in the association" do
+
+      it "returns the document at the index" do
+        @association[0].should be_a_kind_of(Address)
+        @association[0].street.should == "Street 1"
+      end
+
+    end
+
+    context "when the index is not present in the association" do
+
+      it "returns nil" do
+        @association[3].should be_nil
+      end
+
+    end
+
+  end
+
+  describe "#<<" do
+
+    before do
+      @association = Mongoid::Associations::EmbedsMany.new(
+        @document,
+        Mongoid::Associations::Options.new(:name => :addresses)
+      )
+      @address = Address.new
+    end
+
+    it "adds the parent document before appending to the array" do
+      @association << @address
+      @association.length.should == 3
+      @address._parent.should == @document
+    end
+
+    it "allows multiple additions" do
+      @association << @address
+      @association << @address
+      @association.length.should == 4
+    end
+
+    it "sets the index of the document in the array" do
+      addr = Address.new
+      @association << addr
+      addr._index.should == 2
+    end
+
+  end
+
+  describe "#build" do
+
+    context "setting the parent relationship" do
+
+      before do
+        @person = Person.new
+      end
+
+      it "happens before any other operation" do
+        address = @person.addresses.build(:set_parent => true, :street => "Madison Ave")
+        address._parent.should == @person
+        @person.addresses.first.should == address
+      end
+
+    end
+
+    context "when a type is not provided" do
+
+      before do
+        @association = Mongoid::Associations::EmbedsMany.new(
+          @document,
+          Mongoid::Associations::Options.new(:name => :addresses)
+        )
+      end
+
+      it "adds a new document to the array with the supplied parameters" do
+        @association.build({ :street => "Street 1" })
+        @association.length.should == 3
+        @association[2].should be_a_kind_of(Address)
+        @association[2].street.should == "Street 1"
+      end
+
+      it "returns the newly built object in the association" do
+        address = @association.build({ :street => "Yet Another" })
+        address.should be_a_kind_of(Address)
+        address.street.should == "Yet Another"
+      end
+
+    end
+
+    context "when a type is provided" do
+
+      before do
+        @association = Mongoid::Associations::EmbedsMany.new(
+          @document,
+          Mongoid::Associations::Options.new(:name => :shapes)
+        )
+      end
+
+      it "instantiates a class of the type" do
+        circle = @association.build({ :radius => 100 }, Circle)
+        circle.should be_a_kind_of(Circle)
+        circle.radius.should == 100
+      end
+
+    end
+
+  end
+
+  context "#count and #size" do
+
+    before do
+      @association = Mongoid::Associations::EmbedsMany.new(
+        @document,
+        Mongoid::Associations::Options.new(:name => :addresses)
+      )
+      @association.target.first.new_record = true
+    end
+
+    it "count returns the number of persisted elements" do
+      @association.count.should == 1
+    end
+
+    it "size returns the total number of elements" do
+      @association.size.should == 2
+    end
+  end
+
+  describe "#create" do
+
+    context "when a type is not provided" do
+
+      before do
+        @association = Mongoid::Associations::EmbedsMany.new(
+          @document,
+          Mongoid::Associations::Options.new(:name => :addresses)
+        )
+        @address = mock(:parentize => true, :write_attributes => true, :_index= => true)
+        Address.expects(:instantiate).returns(@address)
+      end
+
+      it "builds and saves a new object" do
+        @address.expects(:save).returns(true)
+        address = @association.create({ :street => "Yet Another" })
+        address.should == @address
+      end
+
+    end
+
+    context "when a type is provided" do
+
+      before do
+        @association = Mongoid::Associations::EmbedsMany.new(
+          @document,
+          Mongoid::Associations::Options.new(:name => :shapes)
+        )
+        @circle = mock(:parentize => true, :write_attributes => true, :_index= => true)
+        Circle.expects(:instantiate).returns(@circle)
+      end
+
+      it "instantiates a class of that type" do
+        @circle.expects(:save).returns(true)
+        circle = @association.create({ :radius => 100 }, Circle)
+        circle.should == @circle
+      end
+
+    end
+
+  end
+
+  describe "#create!" do
+
+    context "when validations pass" do
+
+      before do
+        @association = Mongoid::Associations::EmbedsMany.new(
+          @document,
+          Mongoid::Associations::Options.new(:name => :addresses)
+        )
+        @address = mock(:parentize => true, :write_attributes => true, :errors => [], :_index= => true)
+        Address.expects(:instantiate).returns(@address)
+      end
+
+      it "builds and saves a new object" do
+        @address.expects(:save).returns(true)
+        address = @association.create!({ :street => "Yet Another" })
+        address.should == @address
+      end
+    end
+
+    context "when validations fail" do
+
+      before do
+        @association = Mongoid::Associations::EmbedsMany.new(
+          @document,
+          Mongoid::Associations::Options.new(:name => :addresses)
+        )
+        @errors  = mock(:full_messages => ["test"], :empty? => false)
+        @address = mock(:parentize => true, :write_attributes => true, :_index= => true)
+        @address.expects(:errors).twice.returns(@errors)
+        Address.expects(:instantiate).returns(@address)
+      end
+
+      it "builds and saves a new object" do
+        @address.expects(:save).returns(false)
+        lambda {
+          @association.create!({ :street => "Yet Another" })
+        }.should raise_error(Mongoid::Errors::Validations)
+      end
+    end
+  end
+
+  describe "#concat" do
+
+    before do
+      @association = Mongoid::Associations::EmbedsMany.new(
+        @document,
+        Mongoid::Associations::Options.new(:name => :addresses)
+      )
+      @address = Address.new
+    end
+
+    it "adds the parent document before appending to the array" do
+      @association.concat [@address]
+      @association.length.should == 3
+      @address._parent.should == @document
+    end
+
+  end
+
+  describe "#clear" do
+
+    before do
+      @association = Mongoid::Associations::EmbedsMany.new(
+        @document,
+        Mongoid::Associations::Options.new(:name => :addresses)
+      )
+      @address = Address.new
+      @association << @address
+    end
+
+    it "clears out the association" do
+      @association.clear
+      @association.size.should == 0
+    end
+
+  end
+
+  describe "#delete_all" do
+
+    before do
+      @association = Mongoid::Associations::EmbedsMany.new(
+        @document,
+        Mongoid::Associations::Options.new(:name => :addresses)
+      )
+      @association.clear
+      @address = Address.instantiate(:street => "Street 1")
+      @association << @address
+    end
+
+    it "aliases to clear" do
+      @address.expects(:delete)
+      @association.delete_all
+      @association.size.should == 0
+    end
+
+    it "returns the number of documents deleted" do
+      @address.expects(:delete)
+      @association.delete_all.should == 1
+    end
+
+    context "when conditions passed" do
+
+      it "deletes the correct documents" do
+        @address.expects(:delete)
+        @association.delete_all(:conditions => { :street => "Street 1" }).should == 1
+        @association.size.should == 0
+      end
+    end
+  end
+
+  describe "#destroy_all" do
+
+    before do
+      @association = Mongoid::Associations::EmbedsMany.new(
+        @document,
+        Mongoid::Associations::Options.new(:name => :addresses)
+      )
+      @association.clear
+      @address = Address.instantiate(:id => "1", :street => "Street 1")
+      @association << @address
+    end
+
+    it "aliases to clear" do
+      @address.expects(:destroy)
+      @association.destroy_all
+      @association.size.should == 0
+    end
+
+    it "returns the number of documents deleted" do
+      @address.expects(:destroy)
+      @association.destroy_all.should == 1
+    end
+
+    context "when conditions passed" do
+
+      it "deletes the correct documents" do
+        @address.expects(:destroy)
+        @association.destroy_all(:conditions => { :street => "Street 1" }).should == 1
+        @association.size.should == 0
+      end
+    end
+  end
+
+  describe "#find" do
+
+    before do
+      @association = Mongoid::Associations::EmbedsMany.new(
+        @document,
+        Mongoid::Associations::Options.new(:name => :addresses)
+      )
+    end
+
+    context "when finding all" do
+
+      it "returns all the documents" do
+        @association.find(:all).should == @association
+      end
+
+    end
+
+    context "when finding by id" do
+
+      it "returns the document in the array with that id" do
+        address = @association.find("street-2")
+        address.should_not be_nil
+      end
+
+    end
+
+  end
+
+  describe "#first" do
+
+    context "when there are elements in the array" do
+
+      before do
+        @association = Mongoid::Associations::EmbedsMany.new(
+          @document,
+          Mongoid::Associations::Options.new(:name => :addresses)
+        )
+      end
+
+      it "returns the first element" do
+        @association.first.should be_a_kind_of(Address)
+        @association.first.street.should == "Street 1"
+      end
+
+    end
+
+    context "when the array is empty" do
+
+      before do
+        @association = Mongoid::Associations::EmbedsMany.new(
+          Person.new,
+          Mongoid::Associations::Options.new(:name => :addresses)
+        )
+      end
+
+      it "returns nil" do
+        @association.first.should be_nil
+      end
+
+    end
+
+  end
+
+  describe "#initialize" do
+
+    context "setting position" do
+
+      before do
+        @canvas = stub(:raw_attributes => { "shapes" => [{ "_type" => "Circle", "radius" => 5 }] }, :observe => true)
+        @association = Mongoid::Associations::EmbedsMany.new(
+          @canvas,
+          Mongoid::Associations::Options.new(:name => :shapes)
+        )
+      end
+
+      it "sets the index of each document" do
+        @association.first._index.should == 0
+      end
+    end
+
+    context "when no extension exists" do
+
+      before do
+        @canvas = stub(:raw_attributes => { "shapes" => [{ "_type" => "Circle", "radius" => 5 }] }, :observe => true)
+        @association = Mongoid::Associations::EmbedsMany.new(
+          @canvas,
+          Mongoid::Associations::Options.new(:name => :shapes)
+        )
+      end
+
+      it "creates the classes based on their types" do
+        circle = @association.first
+        circle.should be_a_kind_of(Circle)
+        circle.radius.should == 5
+      end
+
+    end
+
+    context "when an extension is in the options" do
+
+      before do
+        @person = Person.new
+        @block = Proc.new do
+          def extension
+            "Testing"
+          end
+        end
+        @association = Mongoid::Associations::EmbedsMany.new(
+          @person,
+          Mongoid::Associations::Options.new(:name => :addresses, :extend => @block)
+        )
+      end
+
+      it "adds the extension module" do
+        @association.extension.should == "Testing"
+      end
+
+    end
+
+  end
+
+  describe ".instantiate" do
+
+    it "delegates to new" do
+      Mongoid::Associations::EmbedsMany.expects(:new).with(@document, @options, nil)
+      Mongoid::Associations::EmbedsMany.instantiate(@document, @options)
+    end
+
+  end
+
+  describe "#length" do
+
+    context "#length" do
+
+      it "returns the length of the delegated array" do
+        @association = Mongoid::Associations::EmbedsMany.new(
+          @document,
+          Mongoid::Associations::Options.new(:name => :addresses)
+        )
+        @association.length.should == 2
+      end
+
+    end
+
+  end
+
+  describe ".macro" do
+
+    it "returns :embeds_many" do
+      Mongoid::Associations::EmbedsMany.macro.should == :embeds_many
+    end
+
+  end
+
+  describe "#nested_build" do
+
+    before do
+      @association = Mongoid::Associations::EmbedsMany.new(
+        @document,
+        Mongoid::Associations::Options.new(:name => :addresses)
+      )
+    end
+
+    it "should update existing documents" do
+      @association.nested_build({ "0" => { :street => "Yet Another" } })
+      @association.size.should == 2
+      @association[0].street.should == "Yet Another"
+    end
+
+    it "should create new documents" do
+      @association.nested_build({ "2" => { :street => "Yet Another" } })
+      @association.size.should == 3
+      @association[2].street.should == "Yet Another"
+    end
+
+  end
+
+  describe "#method_missing" do
+
+    context "when the association class has a criteria class method" do
+
+      before do
+        @association = Mongoid::Associations::EmbedsMany.new(
+          @document,
+          Mongoid::Associations::Options.new(:name => :addresses)
+        )
+      end
+
+      it "returns the criteria" do
+        @association.california.should be_a_kind_of(Mongoid::Criteria)
+      end
+
+      it "sets the documents on the criteria" do
+        criteria = @association.california
+        criteria.documents.should == @association.entries
+      end
+
+      it "returns the scoped documents" do
+        addresses = @association.california
+        addresses.size.should == 1
+        addresses.first.should be_a_kind_of(Address)
+        addresses.first.state.should == "CA"
+      end
+
+    end
+
+    context "when no class method exists" do
+
+      before do
+        @association = Mongoid::Associations::EmbedsMany.new(
+          @document,
+          Mongoid::Associations::Options.new(:name => :addresses)
+        )
+      end
+
+      it "delegates to the array" do
+        @association.entries.size.should == 2
+      end
+
+    end
+
+  end
+
+  describe "#paginate" do
+
+    before do
+      @association = Mongoid::Associations::EmbedsMany.new(
+        @document,
+        Mongoid::Associations::Options.new(:name => :addresses)
+      )
+      @options = { :page => 1, :per_page => 10 }
+      @criteria = mock
+    end
+
+    it "creates a criteria and paginates it" do
+      Mongoid::Criteria.expects(:translate).with(Address, @options).returns(@criteria)
+      @criteria.expects(:documents=).with(@association.target)
+      @criteria.expects(:paginate).returns([])
+      @association.paginate(@options).should == []
+    end
+  end
+
+  describe "#push" do
+
+    before do
+      @association = Mongoid::Associations::EmbedsMany.new(
+        @document,
+        Mongoid::Associations::Options.new(:name => :addresses)
+      )
+      @address = Address.new
+    end
+
+    it "adds the parent document before appending to the array" do
+      @association.push @address
+      @association.length.should == 3
+      @address._parent.should == @document
+    end
+
+    it "appends the document to the end of the array" do
+      @association.push(Address.new)
+      @association.length.should == 3
+    end
+
+  end
+
+  describe ".update" do
+
+    before do
+      @address = Address.new(:street => "Madison Ave")
+      @person = Person.new(:title => "Sir")
+      @association = Mongoid::Associations::EmbedsMany.update(
+        [@address],
+        @person,
+        Mongoid::Associations::Options.new(:name => :addresses)
+      )
+    end
+
+    it "parentizes the child document" do
+      @address._parent.should == @person
+    end
+
+    it "sets the attributes of the child on the parent" do
+      @person.attributes[:addresses].should ==
+        [{ "_id" => "madison-ave", "street" => "Madison Ave" }]
+    end
+
+    it "returns the association proxy" do
+      @association.target.size.should == 1
+    end
+
+  end
+
+end