mongomodel 0.1

data/spec/mongomodel/document_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+module MongoModel
+  specs_for(Document) do
+    it "should inherit from EmbeddedDocument" do
+      Document.ancestors.should include(EmbeddedDocument)
+    end
+    
+    it "should have an id property" do
+      property = Document.properties[:id]
+      property.name.should == :id
+      property.as.should == '_id'
+      property.default(mock('instance')).should_not be_nil
+    end
+    
+    describe "single collection inheritance" do
+      define_class(:Event, Document)
+      define_class(:SpecialEvent, :Event)
+      define_class(:VerySpecialEvent, :SpecialEvent)
+      
+      let(:missing) do
+        e = Event.new
+        e.type = 'MissingClass'
+        e.save!
+        e
+      end
+      
+      before(:each) do
+        @event = Event.create!
+        @special = SpecialEvent.create!
+        @very_special = VerySpecialEvent.create!
+        @missing = missing
+      end
+      
+      it "should belong to the same collection as its parent" do
+        SpecialEvent.collection_name.should == Event.collection_name
+        VerySpecialEvent.collection_name.should == Event.collection_name
+      end
+      
+      it "should be an instance of the correct class when loaded" do
+        Event.find(@event.id).should be_an_instance_of(Event)
+        Event.find(@special.id).should be_an_instance_of(SpecialEvent)
+        Event.find(@very_special.id).should be_an_instance_of(VerySpecialEvent)
+        
+        SpecialEvent.find(@special.id).should be_an_instance_of(SpecialEvent)
+        SpecialEvent.find(@very_special.id).should be_an_instance_of(VerySpecialEvent)
+        
+        VerySpecialEvent.find(@very_special.id).should be_an_instance_of(VerySpecialEvent)
+      end
+      
+      it "should default to superclass type if type missing" do
+        Event.find(@missing.id).should be_an_instance_of(Event)
+      end
+      
+      it "should consider document missing when finding from subclass using id of parent instance" do
+        lambda { SpecialEvent.find(@event.id) }.should raise_error(MongoModel::DocumentNotFound)
+        lambda { VerySpecialEvent.find(@special.id) }.should raise_error(MongoModel::DocumentNotFound)
+      end
+      
+      describe "loading documents" do
+        it "should load all documents from root class" do
+          Event.all.should include(@event, @special, @very_special, @missing)
+        end
+        
+        it "should only load subclass documents from subclass" do
+          SpecialEvent.all.should include(@special, @very_special)
+          SpecialEvent.all.should_not include(@event, @missing)
+          
+          VerySpecialEvent.all.should == [@very_special]
+        end
+      end
+    end
+  end
+end

data/spec/mongomodel/embedded_document_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+module MongoModel
+  specs_for(EmbeddedDocument, Document) do
+    describe "equality" do
+      define_class(:DocumentA, described_class) do
+        property :name, String
+      end
+      
+      define_class(:DocumentB, described_class) do
+        property :name, String
+      end
+    
+      subject { DocumentA.new(:id => 'test', :name => 'Test') }
+    
+      it "should be equal to another document of the same class with identical attributes" do
+        subject.should == DocumentA.new(:id => 'test', :name => 'Test')
+      end
+      
+      it "should not be equal to another document of the same class with different attributes" do
+        subject.should_not == DocumentA.new(:id => 'test', :name => 'Different')
+        subject.should_not == DocumentA.new(:id => 'test', :name => 'Test', :special_attribute => 'Different')
+      end
+      
+      it "should not be equal to another document of a different class with identical attributes" do
+        subject.should_not == DocumentB.new(:id => 'test', :name => 'Different')
+      end
+    end
+    
+    it "should be an abstract class" do
+      described_class.should be_an_abstract_class
+    end
+    
+    describe "subclasses" do
+      define_class(:TestDocument, described_class)
+      
+      it "should not be an abstract class" do
+        TestDocument.should_not be_an_abstract_class
+      end
+    end
+  end
+  
+  specs_for(EmbeddedDocument) do
+    describe "single collection inheritance" do
+      define_class(:Event, EmbeddedDocument)
+      define_class(:SpecialEvent, :Event)
+      
+      define_class(:Parent, Document) do
+        property :event, Event
+      end
+      
+      let(:event) { Event.new }
+      let(:special) { SpecialEvent.new }
+      let(:parent) { Parent.new(:event => special) }
+      let(:reloaded) { parent.save!; Parent.find(parent.id) }
+      
+      it "should not typecast to parent type when assigning to property" do
+        parent.event.should be_an_instance_of(SpecialEvent)
+      end
+      
+      it "should be an instance of the correct class when reloaded" do
+        reloaded.event.should be_an_instance_of(SpecialEvent)
+      end
+    end
+  end
+end

data/spec/mongomodel/mongomodel_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe MongoModel do
+  describe "setting a custom database configuration" do
+    before(:each) do
+      MongoModel.configuration = {
+        'host'     => '127.0.0.1',
+        'database' => 'mydb'
+      }
+    end
+    
+    it "should should merge configuration with defaults" do
+      MongoModel.configuration.host.should == '127.0.0.1'
+      MongoModel.configuration.port.should == 27017
+      MongoModel.configuration.database.should == 'mydb'
+    end
+    
+    it "should establish database connection to given database" do
+      database = MongoModel.database
+      connection = database.connection
+
+      connection.host.should == '127.0.0.1'
+      connection.port.should == 27017
+      database.name.should == 'mydb'
+    end
+  end
+  
+  it "should have a logger accessor" do
+    logger = mock('logger')
+    MongoModel.logger = logger
+    MongoModel.logger.should == logger
+  end
+end

data/spec/mongomodel/support/collection_spec.rb

@@ -0,0 +1,248 @@
+require 'spec_helper'
+
+module MongoModel
+  describe Collection do
+    define_class(:TestDocument, EmbeddedDocument)
+    let(:doc) { TestDocument.new }
+    
+    subject { Collection }
+    
+    it { should be_a_subclass_of(Array) }
+    
+    it "should have type Object" do
+      subject.type.should == Object
+    end
+    
+    it "should not show its type when inspecting" do
+      subject.inspect.should == "Collection"
+    end
+    
+    it "should allow any object to be added to the collection" do
+      collection = subject.new
+      collection << 123
+      collection << "Hello"
+      collection << doc
+      collection.should == [123, "Hello", doc]
+    end
+    
+    it "should convert to mongo representation" do
+      collection = subject.new([123, "Hello", doc])
+      collection.to_mongo.should == [123, "Hello", { "_type" => 'TestDocument' }]
+    end
+    
+    it "should load from mongo representation" do
+      collection = subject.from_mongo([123, "Hello", { "_type" => 'TestDocument' }])
+      collection.should be_a(subject)
+      collection.should == [123, "Hello", doc]
+    end
+    
+    it "should cache collection types" do
+      Collection[String].should equal(Collection[String])
+      Collection[TestDocument].should equal(Collection[TestDocument])
+    end
+    
+    describe "a Collection of Strings" do
+      subject { Collection[String] }
+      
+      it { should be_a_subclass_of(Collection) }
+      it { should be_a_subclass_of(Array) }
+      
+      it "should have type String" do
+        subject.type.should == String
+      end
+      
+      it "should show its type when inspecting" do
+        subject.inspect.should == "Collection[String]"
+      end
+      
+      it "should convert to mongo representation" do
+        collection = subject.new(["a", "bcd", "efg"])
+        collection.to_mongo.should == ["a", "bcd", "efg"]
+      end
+      
+      it "should load from mongo representation" do
+        collection = subject.from_mongo(["a", "bcd", "efg"])
+        collection.should be_a(subject)
+        collection.should == ["a", "bcd", "efg"]
+      end
+      
+      describe "casting" do
+        subject { Collection[String].new }
+        
+        it "should cast elements when instantiating" do
+          Collection[String].new(["abc", 123, 56.2]).should == ["abc", "123", "56.2"]
+        end
+
+        it "should cast elements on <<" do
+          subject << "abc"
+          subject << 123
+          subject << 56.2
+          subject.should == ["abc", "123", "56.2"]
+        end
+        
+        it "should cast elements on []=" do
+          subject[0] = "abc"
+          subject[1] = 123
+          subject[2] = 56.2
+          subject.should == ["abc", "123", "56.2"]
+        end
+        
+        it "should cast elements on +" do
+          result = subject + ["abc", 123, 56.2]
+          result.should be_an_instance_of(Collection[String])
+          result.should == ["abc", "123", "56.2"]
+        end
+        
+        it "should cast elements on concat" do
+          subject.concat(["abc", 123, 56.2])
+          subject.should == ["abc", "123", "56.2"]
+        end
+        
+        it "should cast elements on delete" do
+          subject.push("abc", 123, 56.2)
+          subject.delete(123)
+          subject.delete(56.2)
+          subject.should == ["abc"]
+        end
+        
+        it "should cast elements on index" do
+          subject.push("abc", 123, 56.2)
+          subject.index(123).should == 1
+          subject.index(56.2).should == 2
+        end
+        
+        it "should cast elements on insert" do
+          subject.insert(0, 56.2)
+          subject.insert(0, "abc")
+          subject.insert(1, 123)
+          subject.should == ["abc", "123", "56.2"]
+        end
+        
+        it "should cast elements on push" do
+          subject.push("abc", 123, 56.2)
+          subject.should == ["abc", "123", "56.2"]
+        end
+        
+        it "should cast elements on rindex" do
+          subject.push("abc", 123, 56.2, 123)
+          subject.rindex(123).should == 3
+          subject.rindex(56.2).should == 2
+        end
+        
+        it "should cast elements on unshift" do
+          subject.unshift("abc")
+          subject.unshift(123, 56.2)
+          subject.should == ["123", "56.2", "abc"]
+        end
+        
+        it "should cast elements on include?" do
+          subject.push("abc", 123, 56.2)
+          subject.should include(123)
+          subject.should include(56.2)
+          subject.should_not include(999)
+        end
+      end
+    end
+    
+    describe "a Collection of embedded documents" do
+      subject { Collection[TestDocument] }
+      
+      it { should be_a_subclass_of(Collection) }
+      it { should be_a_subclass_of(Array) }
+      
+      it "should have type TestDocument" do
+        subject.type.should == TestDocument
+      end
+      
+      it "should show its type when inspecting" do
+        subject.inspect.should == "Collection[TestDocument]"
+      end
+      
+      it "should convert to mongo representation" do
+        collection = subject.new([doc])
+        collection.to_mongo.should == [{ "_type" => 'TestDocument' }]
+      end
+      
+      it "should load from mongo representation" do
+        collection = subject.from_mongo([{ "_type" => 'TestDocument' }])
+        collection.should be_a(subject)
+        collection.should == [doc]
+      end
+    end
+    
+    describe "a Collection of CustomClasses" do
+      subject { Collection[CustomClass] }
+      
+      it { should be_a_subclass_of(Collection) }
+      it { should be_a_subclass_of(Array) }
+      
+      it "should have type CustomClass" do
+        subject.type.should == CustomClass
+      end
+      
+      it "should show its type when inspecting" do
+        subject.inspect.should == "Collection[CustomClass]"
+      end
+      
+      it "should convert to mongo representation" do
+        collection = subject.new([CustomClass.new("abc"), CustomClass.new("123")])
+        collection.to_mongo.should == [{ :name => "abc" }, { :name => "123" }]
+      end
+      
+      it "should load from mongo representation" do
+        collection = subject.from_mongo([{ :name => "abc" }, { :name => "123" }])
+        collection.should be_a(subject)
+        collection.should == [CustomClass.new("abc"), CustomClass.new("123")]
+      end
+    end
+  end
+  
+  specs_for(Document, EmbeddedDocument) do
+    describe "defining a Collection property with default value" do
+      define_class(:TestDocument, described_class) do
+        property :test_collection, Collection[CustomClass], :default => ['abc', 'def']
+      end
+      
+      subject { TestDocument.new }
+      
+      it "should cast items to collection type" do
+        subject.test_collection.should == [CustomClass.new('abc'), CustomClass.new('def')]
+      end
+      
+      it "should allow items to be added to collection" do
+        subject.test_collection << '123'
+        subject.test_collection.should == [CustomClass.new('abc'), CustomClass.new('def'), CustomClass.new('123')]
+      end
+      
+      it "should not share collections between instances" do
+        subject.test_collection << '123'
+        TestDocument.new.test_collection.should_not == subject.test_collection
+      end
+    end
+    
+    describe "with a Collection containing EmbeddedDocuments" do
+      define_class(:Embedded, EmbeddedDocument) do
+        property :number, Integer
+      end
+      
+      define_class(:TestDocument, described_class) do
+        property :embedded, Embedded
+        property :embedded_collection, Collection[Embedded]
+      end
+      
+      let(:embedded1) { Embedded.new(:number => 1) }
+      let(:embedded2) { Embedded.new(:number => 2) }
+      let(:embedded3) { Embedded.new(:number => 3) }
+      
+      subject { TestDocument.new(:embedded => embedded1, :embedded_collection => [embedded2, embedded3]) }
+      
+      it "should include the embedded properties in the embedded documents list" do
+        subject.embedded_documents.should include(embedded1)
+      end
+      
+      it "should include the elements in the collection in the embedded documents list" do
+        subject.embedded_documents.should include(embedded2, embedded3)
+      end
+    end
+  end
+end

data/spec/mongomodel/support/mongo_options_spec.rb

@@ -0,0 +1,295 @@
+require 'spec_helper'
+
+module MongoModel
+  describe MongoOptions do
+    define_class(:TestDocument, Document)
+    
+    shared_examples_for "options without conditions" do
+      it "should have an empty selector hash" do
+        subject.selector.should == {}
+      end
+    end
+    
+    shared_examples_for "options with conditions only" do
+      it "should have an empty options hash" do
+        subject.options.should == {}
+      end
+    end
+    
+    context "with blank options" do
+      subject { MongoOptions.new(TestDocument) }
+      
+      it_should_behave_like "options without conditions"
+      
+      it "should have an empty options hash" do
+        subject.options.should == {}
+      end
+    end
+    
+    context "with basic conditions" do
+      subject { MongoOptions.new(TestDocument, :conditions => { :foo => 'bar' }) }
+      
+      it_should_behave_like "options with conditions only"
+      
+      it "should include the conditions in the selector" do
+        subject.selector.should == { :foo => 'bar' }
+      end
+    end
+    
+    context "with conditions using an operator" do
+      subject { MongoOptions.new(TestDocument, :conditions => { :age.gt => 10 }) }
+      
+      it_should_behave_like "options with conditions only"
+      
+      it "should include the expanded conditions in the selector" do
+        subject.selector.should == { :age => { '$gt' => 10 } }
+      end
+    end
+    
+    context "with conditions using a property" do
+      subject { MongoOptions.new(TestDocument, :conditions => { :id => '123' }) }
+      
+      it_should_behave_like "options with conditions only"
+      
+      it "should use the property as value in the selector" do
+        subject.selector.should == { '_id' => '123' }
+      end
+    end
+    
+    context "with basic options (no conditions or order)" do
+      subject { MongoOptions.new(TestDocument, :offset => 20, :limit => 10, :select => [ :foo, :bar ]) }
+      
+      it_should_behave_like "options without conditions"
+      
+      it "should include converted options in options hash" do
+        subject.options.should == { :skip => 20, :limit => 10, :fields => [ :foo, :bar ]}
+      end
+    end
+    
+    context "with string order" do
+      subject { MongoOptions.new(TestDocument, :order => 'foo DESC') }
+      
+      it_should_behave_like "options without conditions"
+      
+      it "should convert order to sort in options hash" do
+        subject.options.should == { :sort => [ ['foo', :descending] ] }
+      end
+    end
+    
+    context "with symbol order" do
+      subject { MongoOptions.new(TestDocument, :order => :bar) }
+      
+      it_should_behave_like "options without conditions"
+      
+      it "should convert order to sort in options hash" do
+        subject.options.should == { :sort => [ ['bar', :ascending] ]}
+      end
+    end
+    
+    context "with symbol(asc) order" do
+      subject { MongoOptions.new(TestDocument, :order => :bar.asc) }
+      
+      it_should_behave_like "options without conditions"
+      
+      it "should convert order to sort in options hash" do
+        subject.options.should == { :sort => [ ['bar', :ascending] ]}
+      end
+    end
+    
+    context "with multiple orders in array" do
+      subject { MongoOptions.new(TestDocument, :order => ['foo ASC', :bar.desc]) }
+      
+      it_should_behave_like "options without conditions"
+      
+      it "should convert order to sort in options hash" do
+        subject.options.should == { :sort => [ ['foo', :ascending], ['bar', :descending]] }
+      end
+    end
+    
+    context "with multiple orders in string" do
+      subject { MongoOptions.new(TestDocument, :order => 'foo DESC, baz') }
+      
+      it_should_behave_like "options without conditions"
+      
+      it "should convert order to sort in options hash" do
+        subject.options.should == { :sort => [ ['foo', :descending], ['baz', :ascending] ] }
+      end
+    end
+    
+    context "with an order using a property" do
+      subject { MongoOptions.new(TestDocument, :order => :id.desc) }
+      
+      it_should_behave_like "options without conditions"
+      
+      it "should use property as value as sort column" do
+        subject.options.should == { :sort => [ ['_id', :descending] ] }
+      end
+    end
+    
+    context "with conditions and options" do
+      subject { MongoOptions.new(TestDocument, :conditions => { :age => 18 }, :order => :id.desc, :limit => 5) }
+      
+      it "should use conditions for selector" do
+        subject.selector.should == { :age => 18 }
+      end
+      
+      it "should convert options" do
+        subject.options.should == { :sort => [ ['_id', :descending] ], :limit => 5 }
+      end
+      
+      it "should convert to array" do
+        subject.to_a.should == [ subject.selector, subject.options ]
+      end
+    end
+  end
+  
+  describe MongoOrder do
+    def c(field, order)
+      MongoOrder::Clause.new(field, order)
+    end
+    
+    subject { MongoOrder.new(c(:name, :ascending), c(:age, :descending)) }
+    
+    it "should convert to string" do
+      subject.to_s.should == "name ascending, age descending"
+    end
+    
+    describe "#to_sort" do
+      it "should convert to mongo sort array" do
+        model = mock('model', :properties => mock('properties', :[] => nil))
+        subject.to_sort(model).should == [['name', :ascending], ['age', :descending]]
+      end
+    end
+    
+    it "should be reversable" do
+      subject.reverse.should == MongoOrder.new(c(:name, :descending), c(:age, :ascending))
+    end
+    
+    it "should equal another order object with identical clauses" do
+      subject.should == MongoOrder.new(c(:name, :ascending), c(:age, :descending))
+    end
+    
+    it "should equal another order object with different clauses" do
+      subject.should_not == MongoOrder.new(c(:name, :ascending))
+      subject.should_not == MongoOrder.new(c(:age, :ascending), c(:name, :ascending))
+    end
+    
+    describe "#parse" do
+      it "should not change a MongoOrder" do
+        MongoOrder.parse(subject).should == subject
+      end
+      
+      it "should convert individual clause to MongoOrder" do
+        MongoOrder.parse(c(:name, :ascending)).should == MongoOrder.new(c(:name, :ascending))
+      end
+      
+      it "should convert symbol to MongoOrder" do
+        MongoOrder.parse(:name).should == MongoOrder.new(c(:name, :ascending))
+      end
+      
+      it "should convert array of clauses to MongoOrder" do
+        MongoOrder.parse([c(:name, :ascending), c(:age, :descending)]).should == MongoOrder.new(c(:name, :ascending), c(:age, :descending))
+      end
+      
+      it "should convert array of symbols to MongoOrder" do
+        MongoOrder.parse([:name, :age]).should == MongoOrder.new(c(:name, :ascending), c(:age, :ascending))
+      end
+      
+      it "should convert array of strings to MongoOrder" do
+        MongoOrder.parse(['name ASC', 'age DESC']).should == MongoOrder.new(c(:name, :ascending), c(:age, :descending))
+      end
+      
+      it "should convert string (no order specified) to MongoOrder" do
+        MongoOrder.parse('name').should == MongoOrder.new(c(:name, :ascending))
+      end
+      
+      it "should convert string (single order) to MongoOrder" do
+        MongoOrder.parse('name DESC').should == MongoOrder.new(c(:name, :descending))
+      end
+      
+      it "should convert string (multiple orders) to MongoOrder" do
+        MongoOrder.parse('name DESC, age ASC').should == MongoOrder.new(c(:name, :descending), c(:age, :ascending))
+      end
+    end
+  end
+  
+  describe MongoOrder::Clause do
+    subject { MongoOrder::Clause.new(:name, :ascending) }
+    
+    it "should convert to string" do
+      subject.to_s.should == "name ascending"
+    end
+    
+    it "should equal another clause with the same field and order" do
+      subject.should == MongoOrder::Clause.new(:name, :ascending)
+    end
+    
+    it "should equal another clause with a different field or order" do
+      subject.should_not == MongoOrder::Clause.new(:age, :ascending)
+      subject.should_not == MongoOrder::Clause.new(:name, :descending)
+    end
+    
+    it "should be reversable" do
+      subject.reverse.should == MongoOrder::Clause.new(:name, :descending)
+    end
+    
+    describe "#to_sort" do
+      context "given property" do
+        it "should use property as value to convert to mongo sort" do
+          property = mock('property', :as => '_name')
+          subject.to_sort(property).should == ['_name', :ascending]
+        end
+      end
+      
+      context "given nil" do
+        it "should convert to mongo sort" do
+          subject.to_sort(nil).should == ['name', :ascending]
+        end
+      end
+    end
+    
+    describe "#parse" do
+      let(:asc) { MongoOrder::Clause.new(:name, :ascending) }
+      let(:desc) { MongoOrder::Clause.new(:name, :descending) }
+      
+      it "should create Clause from string (no order)" do
+        MongoOrder::Clause.parse('name').should == asc
+      end
+      
+      it "should create Clause from string (with order)" do
+        MongoOrder::Clause.parse('name ASC').should == asc
+        MongoOrder::Clause.parse('name asc').should == asc
+        MongoOrder::Clause.parse('name ascending').should == asc
+        MongoOrder::Clause.parse('name DESC').should == desc
+        MongoOrder::Clause.parse('name desc').should == desc
+        MongoOrder::Clause.parse('name descending').should == desc
+      end
+    end
+  end
+  
+  describe MongoOperator do
+    subject { MongoOperator.new(:age, :gt) }
+    
+    it "should convert to mongo selector" do
+      subject.to_mongo_selector(14).should == { '$gt' => 14 }
+    end
+    
+    it "should be equal to a MongoOperator with the same field and operator" do
+      subject.should == MongoOperator.new(:age, :gt)
+    end
+    
+    it "should not be equal to a MongoOperator with a different field/operator" do
+      subject.should_not == MongoOperator.new(:age, :lte)
+      subject.should_not == MongoOperator.new(:date, :gt)
+    end
+    
+    it "should be created from symbol methods" do
+      :age.gt.should == MongoOperator.new(:age, :gt)
+      :date.lte.should == MongoOperator.new(:date, :lte)
+    end
+    
+    it "should be equal within a hash" do
+      { :age.gt => 10 }.should == { :age.gt => 10 }
+    end
+  end
+end