mongoid 1.2.14 → 1.9.0

data/spec/integration/mongoid/extensions_spec.rb

@@ -1,26 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Extensions do
-
-  context "setting floating point numbers" do
-
-    context "when value is an empty string" do
-
-      let(:person) { Person.new(:ssn => "555555555555555") }
-
-      before do
-        Person.validates_numericality_of :blood_alcohol_content, :allow_blank => true
-      end
-
-      after do
-        Person.validations.clear
-      end
-
-      it "does not set the value" do
-        person.save.should be_true
-      end
-
-    end
-  end
-
-end

data/spec/integration/mongoid/finders_spec.rb

@@ -1,119 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Finders do
-
-  describe "#find" do
-
-    context "using string ids" do
-
-      before do
-        @documents = []
-        @document = Person.create(:title => "Mrs.", :ssn => "another")
-        3.times do |n|
-          @documents << Person.create(:title => "Mr.", :ssn => "#{n}22")
-        end
-      end
-
-      after do
-        Person.delete_all
-      end
-
-      context "with an id as an argument" do
-
-        context "when the document is found" do
-
-          it "returns the document" do
-            Person.find(@document.id).should == @document
-          end
-
-        end
-
-        context "when the document is not found" do
-
-          it "raises an error" do
-            lambda { Person.find("5") }.should raise_error
-          end
-
-        end
-
-      end
-
-      context "with an array of ids as args" do
-
-        context "when the documents are found" do
-
-          it "returns an array of the documents" do
-            @people = Person.find(@documents.map(&:id))
-            @people.should == @documents
-          end
-
-        end
-
-        context "when no documents found" do
-
-          it "raises an error" do
-            lambda { Person.find(["11", "21", "31"]) }.should raise_error
-          end
-
-        end
-      end
-    end
-
-    context "using object ids" do
-
-      before do
-        Mongoid.use_object_ids = true
-        @documents = []
-        @document = Person.create(:title => "Mrs.", :ssn => "another")
-        3.times do |n|
-          @documents << Person.create(:title => "Mr.", :ssn => "#{n}22")
-        end
-      end
-
-      after do
-        Mongoid.use_object_ids = false
-        Person.delete_all
-      end
-
-      context "with an id as an argument" do
-
-        context "when the document is found" do
-
-          it "returns the document" do
-            Person.find(@document.id).should == @document
-          end
-
-        end
-
-        context "when the document is not found" do
-
-          it "raises an error" do
-            lambda { Person.find("5") }.should raise_error
-          end
-
-        end
-
-      end
-
-      context "with an array of ids as args" do
-
-        context "when the documents are found" do
-
-          it "returns an array of the documents" do
-            @people = Person.find(@documents.map(&:id))
-            @people.should == @documents
-          end
-
-        end
-
-        context "when no documents found" do
-
-          it "raises an error" do
-            lambda { Person.find(["11", "21", "31"]) }.should raise_error
-          end
-
-        end
-      end
-    end
-  end
-end

data/spec/integration/mongoid/inheritance_spec.rb

@@ -1,137 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Document do
-
-  before do
-    Browser.delete_all
-    Firefox.delete_all
-    Canvas.delete_all
-  end
-
-  context "when document is a subclass of a root class" do
-
-    before do
-      Browser.delete_all
-      @browser = Browser.create(:version => 3, :name => "Test")
-    end
-
-    it "saves in the same collection as the root" do
-      collection = Mongoid.master.collection("canvases")
-      attributes = collection.find({ :name => "Test"}, {}).next_document
-      attributes["version"].should == 3
-      attributes["name"].should == "Test"
-      attributes["_type"].should == "Browser"
-      attributes["_id"].should == @browser.id
-    end
-
-  end
-
-  context "when document is a subclass of a subclass" do
-
-    before do
-      Firefox.delete_all
-      @firefox = Firefox.create(:version => 2, :name => "Testy")
-    end
-
-    it "saves in the same collection as the root" do
-      collection = Mongoid.master.collection("canvases")
-      attributes = collection.find({ :name => "Testy"}, {}).next_document
-      attributes["version"].should == 2
-      attributes["name"].should == "Testy"
-      attributes["_type"].should == "Firefox"
-      attributes["_id"].should == @firefox.id
-    end
-
-    it "returns the document when querying for superclass" do
-      Browser.where(:name => "Testy").first.should == @firefox
-    end
-
-    it "returns the document when querying for root class" do
-      Canvas.where(:name => "Testy").first.should == @firefox
-    end
-
-  end
-
-  context "when document has associations" do
-
-    before do
-      Firefox.delete_all
-      @firefox = Firefox.new(:name => "firefox")
-      @writer = HtmlWriter.new(:speed => 100)
-      @circle = Circle.new(:radius => 50)
-      @square = Square.new(:width => 300, :height => 150)
-      @firefox.writer = @writer
-      @firefox.shapes << [ @circle, @square ]
-      @firefox.save
-    end
-
-    after do
-      Firefox.delete_all
-    end
-
-    it "properly saves a has one subclass" do
-      from_db = Firefox.find(@firefox.id)
-      from_db.should be_a_kind_of(Firefox)
-      from_db.writer.should be_a_kind_of(HtmlWriter)
-      from_db.writer.should == @writer
-    end
-
-    it "properly saves a has many subclass" do
-      from_db = Firefox.find(@firefox.id)
-      from_db.shapes.first.should == @circle
-      from_db.shapes.first.should be_a_kind_of(Circle)
-      from_db.shapes.last.should == @square
-      from_db.shapes.last.should be_a_kind_of(Square)
-    end
-
-    it "properly sets up the belongs to" do
-      from_db = Firefox.find(@firefox.id)
-      circle = from_db.shapes.first
-      circle.should == @circle
-      circle.canvas.should == @firefox
-    end
-
-  end
-
-  context "when document has subclasses" do
-
-    before do
-      @firefox = Firefox.create(:name => "firefox")
-    end
-
-    after do
-      Firefox.delete_all
-    end
-
-    it "returns subclasses for querying parents" do
-      firefox = Canvas.where(:name => "firefox").first
-      firefox.should be_a_kind_of(Firefox)
-      firefox.should == @firefox
-    end
-
-  end
-
-  context "deleting subclasses" do
-
-    before do
-      @firefox = Firefox.create(:name => "firefox")
-      @browser = Browser.create(:name => "browser")
-      @canvas = Canvas.create(:name => "canvas")
-    end
-
-    after do
-      Firefox.delete_all
-      Browser.delete_all
-      Canvas.delete_all
-    end
-
-    it "deletes from the parent class collection" do
-      @firefox.delete
-      Firefox.count.should == 0
-      Browser.count.should == 1
-      Canvas.count.should == 2
-    end
-
-  end
-
-end

data/spec/integration/mongoid/named_scope_spec.rb

@@ -1,46 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::NamedScope do
-
-  describe ".named_scope" do
-
-    class ::Person
-      named_scope :doctors, {:where => {:title => 'Dr.'} }
-      named_scope :old, criteria.where(:age.gt => 50)
-    end
-
-    before do
-      @document = Person.create(:title => "Dr.", :age => 65, :terms => true)
-    end
-
-    after do
-      Person.delete_all
-    end
-
-    context "accessing a single named scope" do
-
-      it "returns the document" do
-        Person.doctors.first.should == @document
-      end
-
-    end
-
-    context "chaining named scopes" do
-
-      it "returns the document" do
-        Person.old.doctors.first.should == @document
-      end
-
-    end
-
-    context "mixing named scopes and class methods" do
-
-      it "returns the document" do
-        Person.accepted.old.doctors.first.should == @document
-      end
-
-    end
-
-  end
-
-end

data/spec/models/address.rb

@@ -1,39 +0,0 @@
-class Address
-  include Mongoid::Document
-  field :address_type
-  field :number, :type => Integer
-  field :street
-  field :city
-  field :state
-  field :post_code
-  field :parent_title
-  field :services, :type => Array
-  key :street
-  has_many :locations
-
-  belongs_to :addressable, :inverse_of => :addresses do
-    def extension
-      "Testing"
-    end
-    def doctor?
-      title == "Dr"
-    end
-  end
-
-  named_scope :rodeo, where(:street => "Rodeo Dr")
-
-  def set_parent=(set = false)
-    self.parent_title = addressable.title if set
-  end
-
-  class << self
-    def california
-      where(:state => "CA")
-    end
-
-    def homes
-      where(:address_type => "Home")
-    end
-
-  end
-end

data/spec/models/animal.rb

@@ -1,6 +0,0 @@
-class Animal
-  include Mongoid::Document
-  field :name
-  key :name
-  belongs_to :person, :inverse_of => :pet
-end

data/spec/models/callbacks.rb

@@ -1,18 +0,0 @@
-class Artist
-  include Mongoid::Document
-  field :name
-  has_many :songs
-
-  after_create :create_songs
-
-  protected
-  def create_songs
-    2.times { |n| songs.create!(:title => "#{n}") }
-  end
-end
-
-class Song
-  include Mongoid::Document
-  field :title
-  belongs_to :artist, :inverse_of => :songs
-end

data/spec/models/comment.rb

@@ -1,8 +0,0 @@
-class Comment
-  include Mongoid::Document
-  include Mongoid::Versioning
-  include Mongoid::Timestamps
-  field :text
-  key :text
-  validates_presence_of :text
-end

data/spec/models/country_code.rb

@@ -1,6 +0,0 @@
-class CountryCode
-  include Mongoid::Document
-  field :code, :type => Integer
-  key :code
-  belongs_to :phone_number, :inverse_of => :country_codes
-end

data/spec/models/employer.rb

@@ -1,5 +0,0 @@
-class Employer
-  def id
-    "1"
-  end
-end

data/spec/models/game.rb

@@ -1,7 +0,0 @@
-class Game
-  include Mongoid::Document
-  field :high_score, :default => 500
-  field :score, :type => Integer, :default => 0
-  belongs_to_related :person
-  enslave and cache
-end

data/spec/models/inheritance.rb

@@ -1,56 +0,0 @@
-class Canvas
-  include Mongoid::Document
-  field :name
-  has_many :shapes
-  has_one :writer
-
-  def render
-    shapes.each { |shape| render }
-  end
-end
-
-class Browser < Canvas
-  field :version, :type => Integer
-  def render; end
-end
-
-class Firefox < Browser
-  field :user_agent
-  def render; end
-end
-
-class Shape
-  include Mongoid::Document
-  field :x, :type => Integer, :default => 0
-  field :y, :type => Integer, :default => 0
-
-  belongs_to :canvas, :inverse_of => :shapes
-
-  def render; end
-end
-
-class Square < Shape
-  field :width, :type => Integer, :default => 0
-  field :height, :type => Integer, :default => 0
-end
-
-class Circle < Shape
-  field :radius, :type => Integer, :default => 0
-end
-
-class Writer
-  include Mongoid::Document
-  field :speed, :type => Integer, :default => 0
-
-  belongs_to :canvas, :inverse_of => :writer
-
-  def write; end
-end
-
-class HtmlWriter < Writer
-  def write; end
-end
-
-class PdfWriter < Writer
-  def write; end
-end