mongomodel 0.1

data/spec/mongomodel/concerns/attribute_methods/before_type_cast_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+module MongoModel
+  specs_for(Document, EmbeddedDocument) do
+    define_class(:TestDocument, described_class) do
+      property :foo, Date
+    end
+    
+    subject { TestDocument.new }
+    
+    describe "#read_attribute_before_type_cast" do
+      context "with property" do
+        it "should return the attribute before type casting" do
+          subject.attributes[:foo] = 'some date'
+          subject.read_attribute_before_type_cast(:foo).should == 'some date'
+        end
+        
+        it "should define a reader method" do
+          subject.attributes[:foo] = 'some date'
+          subject.foo_before_type_cast.should == 'some date'
+        end
+      end
+      
+      context "no property" do
+        it "should return the attribute without type casting" do
+          subject.attributes[:bar] = 'set bar'
+          subject.read_attribute_before_type_cast(:bar).should == 'set bar'
+        end
+        
+        it "should not define a reader method" do
+          lambda { subject.bar_before_type_cast }.should raise_error(NoMethodError)
+        end
+      end
+    end
+    
+    describe "#attributes_before_type_cast" do
+      it "should return a hash of attributes before type casting" do
+        subject.attributes[:foo] = 'some date'
+        subject.attributes[:bar] = 'set bar'
+        
+        subject.attributes_before_type_cast[:foo].should == 'some date'
+        subject.attributes_before_type_cast[:bar].should == 'set bar'
+      end
+    end
+  end
+end

data/spec/mongomodel/concerns/attribute_methods/dirty_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+module MongoModel
+  specs_for(Document, EmbeddedDocument) do
+    if specing?(Document)
+      define_class(:TestDocument, Document) do
+        property :foo, String
+        property :bar, String
+      end
+
+      subject { TestDocument.create!(:foo => 'original foo') }
+    else
+      define_class(:ChildDocument, EmbeddedDocument) do
+        property :foo, String
+        property :bar, String
+      end
+      
+      define_class(:ParentDocument, Document) do
+        property :child, ChildDocument
+      end
+      
+      let(:child) { ChildDocument.new(:foo => 'original foo') }
+      let(:parent) { ParentDocument.create!(:child => child) }
+      
+      subject { parent.child }
+    end
+    
+    describe "#write_attribute" do
+      before(:each) do
+        subject.write_attribute(:foo, 'new foo')
+      end
+      
+      it "should add the old attribute name to the changed attributes" do
+        subject.changed.should include(:foo)
+      end
+      
+      it "should not add other attributes to the changed attributes" do
+        subject.changed.should_not include(:bar)
+      end
+      
+      it "should add the changed attribute value to the changes hash" do
+        subject.changes[:foo].should == ['original foo', 'new foo']
+      end
+      
+      context "when called twice" do
+        before(:each) do
+          subject.write_attribute(:foo, 'new foo #2')
+        end
+        
+        it "should keep the original value as the old value in the changes hash" do
+          subject.changes[:foo].should == ['original foo', 'new foo #2']
+        end
+      end
+    end
+    
+    context "with changed attributes" do
+      context "attribute set to a new value" do
+        before(:each) do
+          subject.foo = 'foo changed'
+        end
+      
+        it { should be_changed }
+      end
+      
+      context "attribute set to the original value" do
+        before(:each) do
+          subject.foo = 'original foo'
+        end
+        
+        it { should_not be_changed }
+      end
+    end
+    
+    context "without changed attributes" do
+      it { should_not be_changed }
+    end
+    
+    context "#original_attributes" do
+      context "with changes" do
+        before(:each) do
+          subject.foo = 'changed foo'
+        end
+        
+        it "should return the attributes before changes" do
+          subject.original_attributes[:foo].should == 'original foo'
+        end
+      end
+      
+      context "without changes" do
+        it "should return the attributes hash" do
+          subject.original_attributes.should == subject.attributes
+        end
+      end
+    end
+  end
+  
+  specs_for(Document) do
+    define_class(:TestDocument, Document) do
+      property :foo, String
+    end
+    
+    subject { TestDocument.create!(:foo => 'original foo') }
+    
+    context "when saved" do
+      before(:each) do
+        subject.foo = 'changed foo'
+      end
+      
+      context "with save" do
+        it "should reset the changed attributes" do
+          subject.save
+          subject.should_not be_changed
+        end
+      end
+      
+      context "with save!" do
+        it "should reset the changed attributes" do
+          subject.save!
+          subject.should_not be_changed
+        end
+      end
+    end
+    
+    context "when instantiated from database" do
+      it "should not be changed" do
+        instance = TestDocument.find(subject.id)
+        instance.should_not be_changed
+      end
+    end
+  end
+end

data/spec/mongomodel/concerns/attribute_methods/protected_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+module MongoModel
+  specs_for(Document, EmbeddedDocument) do
+    define_class(:TestDocument, described_class) do
+      property :foo, String
+      property :bar, String
+    end
+    
+    subject { TestDocument.new }
+    
+    describe "#attr_protected" do
+      before(:each) do
+        TestDocument.attr_protected :foo
+      end
+      
+      it "should disallow the attribute to be mass-assigned via attributes=" do
+        subject.attributes = { :foo => 'value of foo' }
+        subject.foo.should be_nil
+      end
+      
+      it "should not disallow the attribute to be assigned individually" do
+        subject.foo = 'value of foo'
+        subject.foo.should == 'value of foo'
+      end
+      
+      it "should not disallow other attributes to be mass-assigned via attributes=" do
+        subject.attributes = { :bar => 'value of bar' }
+        subject.bar.should == 'value of bar'
+      end
+      
+      it "should accept multiple attributes" do
+        TestDocument.attr_protected :foo, :bar
+        
+        subject.attributes = { :foo => 'value of foo', :bar => 'value of bar' }
+        subject.foo.should be_nil
+        subject.bar.should be_nil
+      end
+    end
+    
+    describe "#attr_accessible" do
+      before(:each) do
+        TestDocument.attr_accessible :foo
+      end
+      
+      it "should allow the attribute to be mass-assigned via attributes=" do
+        subject.attributes = { :foo => 'value of foo' }
+        subject.foo.should == 'value of foo'
+      end
+      
+      it "should not disallow other attributes to be mass-assigned via attributes=" do
+        subject.attributes = { :bar => 'value of bar' }
+        subject.bar.should be_nil
+      end
+      
+      it "should not disallow others attributes to be assigned individually" do
+        subject.bar = 'value of bar'
+        subject.bar.should == 'value of bar'
+      end
+      
+      it "should accept multiple attributes" do
+        TestDocument.attr_accessible :foo, :bar
+        
+        subject.attributes = { :foo => 'value of foo', :bar => 'value of bar' }
+        subject.foo.should == 'value of foo'
+        subject.bar.should == 'value of bar'
+      end
+    end
+    
+    describe "#property" do
+      context "with :protected option" do
+        it "should make the attribute protected" do
+          TestDocument.should_receive(:attr_protected).with(:baz)
+          TestDocument.property :baz, String, :protected => true
+        end
+      end
+      
+      context "with :accessible option" do
+        it "should make the attribute accessible" do
+          TestDocument.should_receive(:attr_accessible).with(:baz)
+          TestDocument.property :baz, String, :accessible => true
+        end
+      end
+    end
+  end
+end

data/spec/mongomodel/concerns/attribute_methods/query_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module MongoModel
+  specs_for(Document, EmbeddedDocument) do
+    define_class(:TestDocument, described_class) do
+      property :foo, String
+    end
+    
+    subject { TestDocument.new }
+    
+    describe "#query_attribute" do
+      it "should return true if the attribute is not blank" do
+        subject.foo = 'set foo'
+        subject.query_attribute(:foo).should be_true
+      end
+      
+      it "should return false if the attribute is blank" do
+        subject.foo = ''
+        subject.query_attribute(:foo).should be_false
+      end
+      
+      it "should create a query method" do
+        subject.foo?.should == subject.query_attribute(:foo)
+      end
+    end
+  end
+end

data/spec/mongomodel/concerns/attribute_methods/read_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+module MongoModel
+  specs_for(Document, EmbeddedDocument) do
+    define_class(:TestDocument, described_class) do
+      property :foo, String
+    end
+    
+    subject { TestDocument.new(:foo => 'value of foo', :bar => 'value of bar') }
+    
+    describe "#read_attribute" do
+      context "valid property" do
+        it "should return the attribute value" do
+          subject.read_attribute(:foo).should == 'value of foo'
+        end
+        
+        it "should define a reader method" do
+          subject.foo.should == 'value of foo'
+        end
+      end
+      
+      context "no property" do
+        it "should return the attribute value" do
+          subject.read_attribute(:bar).should == 'value of bar'
+        end
+        
+        it "should not define a reader method" do
+          lambda { subject.bar }.should raise_error(NoMethodError)
+        end
+      end
+    end
+    
+    describe "#[]" do
+      it "should read the given attribute" do
+        subject.should_receive(:read_attribute).with(:foo).and_return('value of foo')
+        subject[:foo].should == 'value of foo'
+      end
+    end
+  end
+  
+  specs_for(Document) do
+    define_class(:TestDocument, Document)
+    
+    subject { TestDocument.new }
+    
+    describe "#id" do
+      it "should return id from attributes" do
+        subject.id.should == subject.attributes[:id]
+      end
+    end
+  end
+end

data/spec/mongomodel/concerns/attribute_methods/write_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+module MongoModel
+  specs_for(Document, EmbeddedDocument) do
+    define_class(:TestDocument, described_class) do
+      property :foo, String
+    end
+    
+    subject { TestDocument.new }
+    
+    describe "#write_attribute" do
+      context "with property" do
+        it "should set the attribute hash" do
+          subject.write_attribute(:foo, 'set foo')
+          subject.attributes[:foo].should == 'set foo'
+        end
+        
+        it "should define a writer method" do
+          subject.foo = 'set foo'
+          subject.attributes[:foo].should == 'set foo'
+        end
+      end
+      
+      context "no property" do
+        it "should set the attribute hash" do
+          subject.write_attribute(:bar, 'set bar')
+          subject.attributes[:bar].should == 'set bar'
+        end
+        
+        it "should not define a writer method" do
+          lambda { subject.bar = 'set bar' }.should raise_error(NoMethodError)
+        end
+      end
+    end
+    
+    describe "#[]=" do
+      it "should write the given attribute" do
+        subject.should_receive(:write_attribute).with(:foo, 'value of foo')
+        subject[:foo] = 'value of foo'
+      end
+    end
+  end
+end

data/spec/mongomodel/concerns/attributes_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+require 'active_support/core_ext/hash/indifferent_access'
+
+module MongoModel
+  AttributeTypes = {
+    String => "my string",
+    Integer => 99,
+    Float => 45.123,
+    Symbol => :foobar,
+    Boolean => false,
+    Array => [ 1, 2, 3, "hello", :world, [99, 100] ],
+    Hash => { :rabbit => 'hat', 'hello' => 12345 }.with_indifferent_access,
+    Date => Date.today,
+    Time => Time.now,
+    CustomClass => CustomClass.new('hello')
+  }
+  
+  specs_for(Document, EmbeddedDocument) do
+    define_class(:TestDocument, described_class)
+    
+    it "should have an attributes store on the instance" do
+      doc = TestDocument.new
+      doc.attributes.should be_an_instance_of(MongoModel::Attributes::Store)
+    end
+    
+    it "should convert to mongo representation" do
+      doc = TestDocument.new
+      doc.to_mongo.should == doc.attributes.to_mongo
+    end
+    
+    AttributeTypes.each do |type, value|
+      describe "setting #{type} attributes" do
+        define_class(:TestDocument, described_class) do
+          property :test_property, type
+        end
+        
+        if specing?(EmbeddedDocument)
+          define_class(:ParentDocument, Document) do
+            property :child, TestDocument
+          end
+          
+          let(:parent) { ParentDocument.create!(:child => TestDocument.new(:test_property => value)) }
+          let(:child) { parent.child }
+          let(:reloaded) { ParentDocument.find(parent.id).child }
+          
+          subject { child }
+        else
+          subject { TestDocument.create!(:test_property => value) }
+          
+          let(:reloaded) { TestDocument.find(subject.id) }
+        end
+        
+        it "should read the correct value from attributes" do
+          subject.test_property.should == value
+        end
+      
+        it "should read the correct value after reloading" do
+          reloaded.test_property.should == subject.test_property
+        end
+      end
+    end
+    
+    it "should have an attributes store" do
+      doc = TestDocument.new
+      doc.attributes.should be_an_instance_of(MongoModel::Attributes::Store)
+    end
+    
+    it "should duplicate attributes when duplicating object" do
+      original = TestDocument.new
+      duplicate = original.dup
+      
+      duplicate.attributes.should_not equal(original.attributes)
+    end
+    
+    describe "initializing" do
+      define_class(:Person, EmbeddedDocument) do
+        property :name, String
+        property :age, Integer, :default => 21
+      end
+      
+      it "should be initializable with attributes hash" do
+        doc = Person.new(:name => 'Fred', :age => 42)
+        doc.name.should == 'Fred'
+        doc.age.should == 42
+      end
+      
+      it "should use default attributes when initializing with partial attributes hash" do
+        doc = Person.new(:name => 'Maurice')
+        doc.age.should == 21
+      end
+      
+      it "should load from mongo representation" do
+        doc = Person.from_mongo({ 'name' => 'James', 'age' => 15 })
+        doc.name.should == 'James'
+        doc.age.should == 15
+      end
+    end
+    
+    describe "setting attributes with hash" do
+      define_class(:TestDocument, described_class) do
+        property :test_property, String
+        
+        def test_property=(value)
+          write_attribute(:test_property, 'set from method')
+        end
+      end
+      
+      subject { TestDocument.new }
+      
+      it "should call custom property methods" do
+        subject.attributes = { :test_property => 'property value' }
+        subject.test_property.should == 'set from method'
+      end
+      
+      it "should use write_attribute if no such property" do
+        subject.attributes = { :non_property => 'property value' }
+        subject.read_attribute(:non_property).should == 'property value'
+      end
+    end
+    
+    describe "#new" do
+      define_class(:TestDocument, described_class)
+      
+      it "should yield the instance to a block if provided" do
+        block_called = false
+        
+        TestDocument.new do |doc|
+          block_called = true
+          doc.should be_an_instance_of(TestDocument)
+        end
+        
+        block_called.should be_true
+      end
+    end
+    
+    context "a frozen instance" do
+      define_class(:TestDocument, described_class) do
+        property :test_property, String
+      end
+      
+      subject { TestDocument.new(:test_property => 'Test') }
+      
+      before(:each) { subject.freeze }
+      
+      it { should be_frozen }
+      
+      it "should not allow changes to the attributes hash" do
+        lambda { subject.attributes[:test_property] = 'Change' }.should raise_error
+      end
+    end
+  end
+end