humanoid 1.2.7

data/spec/models/location.rb

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

data/spec/models/mixed_drink.rb

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

data/spec/models/name.rb

@@ -0,0 +1,13 @@
+class Name
+  include Humanoid::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

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

data/spec/models/patient.rb

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

data/spec/models/person.rb

@@ -0,0 +1,98 @@
+class Person
+  include Humanoid::Document
+  include Humanoid::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
+
+  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

@@ -0,0 +1,7 @@
+class Pet
+  include Humanoid::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

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

data/spec/models/phone.rb

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

data/spec/models/post.rb

@@ -0,0 +1,15 @@
+class Post
+  include Humanoid::Document
+  include Humanoid::Versioning
+  include Humanoid::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

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

data/spec/models/vet_visit.rb

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

data/spec/spec.opts

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

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+$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

@@ -0,0 +1,141 @@
+require "spec_helper"
+
+describe Humanoid::Associations::BelongsToRelated do
+
+  describe ".initialize" do
+
+    context "when related id has been set" do
+
+      before do
+        @document = stub(:person_id => "5")
+        @options = Humanoid::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 = Humanoid::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 = Humanoid::Associations::Options.new(:name => :person, :extend => @block)
+        @related = stub
+        Person.expects(:find).with(@document.person_id).returns(@related)
+        @association = Humanoid::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 = Humanoid::Associations::Options.new(:name => :person)
+      end
+
+      it "delegates to new" do
+        Humanoid::Associations::BelongsToRelated.expects(:new).with(@document, "5", @options, nil)
+        Humanoid::Associations::BelongsToRelated.instantiate(@document, @options)
+      end
+
+    end
+
+    context "when foreign key is nil" do
+
+      before do
+        @document = stub(:person_id => nil)
+        @options = Humanoid::Associations::Options.new(:name => :person)
+      end
+
+      it "returns nil" do
+        Humanoid::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 = Humanoid::Associations::Options.new(:name => :person)
+      Person.expects(:find).with(@document.person_id).returns(@person)
+      @association = Humanoid::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
+      Humanoid::Associations::BelongsToRelated.macro.should == :belongs_to_related
+    end
+
+  end
+
+  describe ".update" do
+
+    before do
+      @related = stub(:id => "5")
+      @child = Game.new
+      @options = Humanoid::Associations::Options.new(:name => :person)
+      @association = Humanoid::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
+        Humanoid::Associations::BelongsToRelated.update(nil, @child, @options).should be_nil
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,193 @@
+require "spec_helper"
+
+describe Humanoid::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
+    Humanoid::Associations::Options.new(:name => :person, :inverse_of => :name)
+  end
+
+  let(:has_many_options) do
+    Humanoid::Associations::Options.new(:name => :person, :inverse_of => :addresses)
+  end
+
+  describe "#find" do
+
+    before do
+      @association = Humanoid::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 = Humanoid::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 = Humanoid::Associations::Options.new(:name => :person, :extend => @block)
+      @association = Humanoid::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 = Humanoid::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
+        Humanoid::Associations::BelongsTo.instantiate(@document, options).should be_nil
+      end
+
+    end
+
+  end
+
+  describe ".macro" do
+
+    it "returns :belongs_to" do
+      Humanoid::Associations::BelongsTo.macro.should == :belongs_to
+    end
+
+  end
+
+  describe "#method_missing" do
+
+    before do
+      @association = Humanoid::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 = Humanoid::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")
+        Humanoid::Associations::BelongsTo.update(@person, @address, has_many_options)
+      end
+
+      it "updates the parent document" do
+        @person.addresses.first.should == @address
+      end
+
+    end
+
+  end
+
+end