mongoid 1.2.14 → 1.9.0

data/spec/models/location.rb

@@ -1,5 +0,0 @@
-class Location
-  include Mongoid::Document
-  field :name
-  belongs_to :address, :inverse_of => :locations
-end

data/spec/models/mixed_drink.rb

@@ -1,4 +0,0 @@
-class MixedDrink
-  include Mongoid::Document
-  field :name
-end

data/spec/models/name.rb

@@ -1,13 +0,0 @@
-class Name
-  include Mongoid::Document
-  field :first_name
-  field :last_name
-  field :parent_title
-  key :first_name, :last_name
-  has_many :translations
-  belongs_to :person, :inverse_of => :name
-
-  def set_parent=(set = false)
-    self.parent_title = person.title if set
-  end
-end

data/spec/models/namespacing.rb

@@ -1,11 +0,0 @@
-module Medical
-  class Patient
-    include Mongoid::Document
-    field :name
-    has_many :prescriptions, :class_name => "Medical::Prescription"
-  end
-  class Prescription
-    include Mongoid::Document
-    field :name
-  end
-end

data/spec/models/patient.rb

@@ -1,4 +0,0 @@
-class Patient
-  include Mongoid::Document
-  store_in :inpatient
-end

data/spec/models/person.rb

@@ -1,99 +0,0 @@
-class Person
-  include Mongoid::Document
-  include Mongoid::Timestamps
-
-  field :title
-  field :terms, :type => Boolean
-  field :pets, :type => Boolean, :default => false
-  field :age, :type => Integer, :default => 100
-  field :dob, :type => Date
-  field :mixed_drink, :type => MixedDrink
-  field :employer_id
-  field :lunch_time, :type => Time
-  field :aliases, :type => Array
-  field :map, :type => Hash
-  field :score, :type => Integer
-  field :blood_alcohol_content, :type => Float, :default => lambda{ 0.0 }
-  field :ssn
-  field :owner_id, :accessible => false, :type => Integer
-
-  index :age
-  index :addresses
-  index :dob
-  index :name
-  index :title
-  index :ssn, :unique => true
-
-  attr_reader :rescored
-
-  has_many :addresses do
-    def extension
-      "Testing"
-    end
-    def find_by_street(street)
-      @target.select { |doc| doc.street == street }
-    end
-  end
-
-  has_many :phone_numbers, :class_name => "Phone"
-
-  has_one :name do
-    def extension
-      "Testing"
-    end
-    def dawkins?
-      first_name == "Richard" && last_name == "Dawkins"
-    end
-  end
-
-  has_one :pet, :class_name => "Animal"
-
-  accepts_nested_attributes_for :addresses, :reject_if => lambda { |attrs| attrs["street"].blank? }
-  accepts_nested_attributes_for :name
-
-  has_one_related :game do
-    def extension
-      "Testing"
-    end
-  end
-
-  has_many_related :posts do
-    def extension
-      "Testing"
-    end
-  end
-
-  def score_with_rescoring=(score)
-    @rescored = score.to_i + 20
-    self.score_without_rescoring = score
-  end
-
-  alias_method_chain :score=, :rescoring
-
-  def update_addresses
-    addresses.each do |address|
-      address.street = "Updated Address"
-    end
-  end
-
-  def employer=(emp)
-    self.employer_id = emp.id
-  end
-
-  class << self
-    def accepted
-      criteria.where(:terms => true)
-    end
-    def knight
-      criteria.where(:title => "Sir")
-    end
-    def old
-      criteria.where(:age => { "$gt" => 50 })
-    end
-  end
-
-end
-
-class Doctor < Person
-  field :specialty
-end

data/spec/models/pet.rb

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

data/spec/models/pet_owner.rb

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

data/spec/models/phone.rb

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

data/spec/models/post.rb

@@ -1,15 +0,0 @@
-class Post
-  include Mongoid::Document
-  include Mongoid::Versioning
-  include Mongoid::Timestamps
-  field :title
-  belongs_to_related :person
-
-  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/translation.rb

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

data/spec/models/vet_visit.rb

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

data/spec/spec.opts

@@ -1,3 +0,0 @@
---colour
---format nested
---drb

data/spec/spec_helper.rb

@@ -1,31 +0,0 @@
-$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 "mocha"
-require "mongoid"
-require "spec"
-
-Mongoid.configure do |config|
-  name = "mongoid_test"
-  host = "localhost"
-  config.master = Mongo::Connection.new.db(name)
-  # 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) }
-
-Spec::Runner.configure do |config|
-  config.mock_with :mocha
-  config.after :suite do
-    Mongoid.master.collections.each(&:drop)
-  end
-end

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

@@ -1,145 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Associations::BelongsToRelated do
-
-  describe ".initialize" do
-
-    context "when related id has been set" do
-
-      before do
-        @document = stub(:person_id => "5")
-        @options = Mongoid::Associations::Options.new(:name => :person)
-        @related = stub
-      end
-
-      it "finds the object by id" do
-        Person.expects(:find).with(@document.person_id).returns(@related)
-        association = Mongoid::Associations::BelongsToRelated.new(@document, "5", @options)
-        association.should == @related
-      end
-
-    end
-
-    context "when options have an extension" do
-
-      before do
-        @document = stub(:person_id => "5")
-        @block = Proc.new {
-          def extension
-            "Testing"
-          end
-        }
-        @options = Mongoid::Associations::Options.new(:name => :person, :extend => @block)
-        @related = stub
-        Person.expects(:find).with(@document.person_id).returns(@related)
-        @association = Mongoid::Associations::BelongsToRelated.new(@document, "5", @options)
-      end
-
-      it "adds the extension module" do
-        @association.extension.should == "Testing"
-      end
-
-    end
-
-  end
-
-  describe ".instantiate" do
-
-    context "when foreign key is not nil" do
-
-      before do
-        @document = stub(:person_id => "5")
-        @options = Mongoid::Associations::Options.new(:name => :person)
-      end
-
-      it "delegates to new" do
-        Mongoid::Associations::BelongsToRelated.expects(:new).with(@document, "5", @options, nil)
-        Mongoid::Associations::BelongsToRelated.instantiate(@document, @options)
-      end
-
-    end
-
-    context "when foreign key is nil" do
-
-      before do
-        @document = stub(:person_id => nil)
-        @options = Mongoid::Associations::Options.new(:name => :person)
-      end
-
-      it "returns nil" do
-        Mongoid::Associations::BelongsToRelated.instantiate(@document, @options).should be_nil
-      end
-
-    end
-
-  end
-
-  describe "#method_missing" do
-
-    before do
-      @person = Person.new(:title => "Mr")
-      @document = stub(:person_id => "5")
-      @options = Mongoid::Associations::Options.new(:name => :person)
-      Person.expects(:find).with(@document.person_id).returns(@person)
-      @association = Mongoid::Associations::BelongsToRelated.new(@document, "5", @options)
-    end
-
-    context "when getting values" do
-
-      it "delegates to the document" do
-        @association.title.should == "Mr"
-      end
-
-    end
-
-    context "when setting values" do
-
-      it "delegates to the document" do
-        @association.title = "Sir"
-        @association.title.should == "Sir"
-      end
-
-    end
-
-  end
-
-  describe ".macro" do
-
-    it "returns :belongs_to_related" do
-      Mongoid::Associations::BelongsToRelated.macro.should == :belongs_to_related
-    end
-
-  end
-
-  describe ".update" do
-
-    before do
-      @related = stub(:id => "5")
-      @child = Game.new
-      @options = Mongoid::Associations::Options.new(:name => :person)
-      @association = Mongoid::Associations::BelongsToRelated.update(@related, @child, @options)
-    end
-
-    it "sets the related object id on the parent" do
-      @child.person_id.should == "5"
-    end
-
-    it "returns the proxy" do
-      @association.target.should == @related
-    end
-
-    context "when target is nil" do
-
-      it "returns nil" do
-        Mongoid::Associations::BelongsToRelated.update(nil, @child, @options).should be_nil
-      end
-
-      it "removes the association" do
-        Mongoid::Associations::BelongsToRelated.update(nil, @child, @options)
-        @child.person.should be_nil
-      end
-    end
-
-  end
-
-end

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

@@ -1,193 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Associations::BelongsTo 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::BelongsTo.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::BelongsTo.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::BelongsTo.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::BelongsTo.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::BelongsTo.instantiate(@document, options).should be_nil
-      end
-
-    end
-
-  end
-
-  describe ".macro" do
-
-    it "returns :belongs_to" do
-      Mongoid::Associations::BelongsTo.macro.should == :belongs_to
-    end
-
-  end
-
-  describe "#method_missing" do
-
-    before do
-      @association = Mongoid::Associations::BelongsTo.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::BelongsTo.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", "_type" => "Name" }
-      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::BelongsTo.update(@person, @address, has_many_options)
-      end
-
-      it "updates the parent document" do
-        @person.addresses.first.should == @address
-      end
-
-    end
-
-  end
-
-end