mark_mapper 0.0.1

data/spec/functional/rails_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe "Documents with the Rails plugin" do
+  let(:doc) { Doc {
+    key :foo, String
+    key :long_field, String, :alias => "lf"
+   }}
+
+  context "with values from the DB" do
+    subject { doc.create(:foo => "bar", :long_field => "long value") }
+    it "should have x_before_type_cast" do
+      subject.foo_before_type_cast.should == "bar"
+    end
+
+    it "should have x_before_type_cast for aliased fields" do
+      subject.long_field_before_type_cast.should == "long value"
+    end
+
+    it "should honor app-set values over DB-set values" do
+      subject.foo = nil
+      subject.foo_before_type_cast.should == nil
+    end
+  end
+
+  context "when blank" do
+    subject { doc.create() }
+    it "should have x_before_type_cast" do
+      subject.foo_before_type_cast.should == nil
+    end
+
+    it "should honor app-set values over DB-set values" do
+      subject.foo = nil
+      subject.foo_before_type_cast.should == nil
+
+      subject.foo = :baz
+      subject.foo_before_type_cast.should == :baz
+
+      subject.save
+      subject.reload.foo_before_type_cast.should == "baz"
+    end
+  end
+
+  context "#has_one" do
+    subject do
+      Doc do
+        has_one :foo
+      end
+    end
+
+    it "should create a one association" do
+      subject.associations.should have_key :foo
+      subject.associations[:foo].should be_a MarkMapper::Plugins::Associations::OneAssociation
+    end
+  end
+end

data/spec/functional/sci_spec.rb

@@ -0,0 +1,374 @@
+require 'spec_helper'
+
+describe "Single collection inheritance (document)" do
+  # context "without a connection", :without_connection => true do
+  #   it "should attempt to create a connection during inheritance" do
+  #     expect(MarkLogic::Connection).to_not receive(:new)
+  #     doc = Class.new
+  #     doc.send(:include, MarkMapper::Document)
+  #     expect {
+  #       Class.new(doc)
+  #     }.to_not raise_error
+  #   end
+
+  #   it "should pick up a connection if one wasn't set" do
+  #     doc = Class.new
+  #     doc.send(:include, MarkMapper::Document)
+  #     klass = Class.new(doc)
+  #     klass.connection.should be_nil
+  #     MarkMapper.connection
+  #     klass.connection.should be_a MarkLogic::Connection
+  #   end
+  # end
+
+  context "with a connection" do
+    before do
+      class ::DocParent
+        include MarkMapper::Document
+        key :name, String
+      end
+      DocParent.collection.remove
+
+      class ::DocDaughter < ::DocParent; end
+      class ::DocSon < ::DocParent; end
+      class ::DocGrandSon < ::DocSon; end
+      class ::DocGrandGrandSon < ::DocGrandSon; end
+
+      DocSon.many :children, :class_name => 'DocGrandSon'
+
+      @parent = DocParent.new({:name => "Daddy Warbucks"})
+      @daughter = DocDaughter.new({:name => "Little Orphan Annie"})
+    end
+
+    after do
+      Object.send :remove_const, 'DocParent'   if defined?(::DocParent)
+      Object.send :remove_const, 'DocDaughter' if defined?(::DocDaughter)
+      Object.send :remove_const, 'DocSon'      if defined?(::DocSon)
+      Object.send :remove_const, 'DocGrandSon' if defined?(::DocGrandSon)
+      Object.send :remove_const, 'DocGrandGrandSon' if defined?(::DocGrandGrandSon)
+    end
+
+    it "should automatically add _type key to store class" do
+      DocParent.key?(:_type).should be_truthy
+    end
+
+    it "should use the same connection in the subclass" do
+      parent_class = Class.new do
+        include MarkMapper::Document
+        connection MarkLogic::Connection.new(HOST, PORT)
+      end
+
+      child_class = Class.new(parent_class) do
+        include MarkMapper::Document
+      end
+
+      child_class.connection.should == child_class.connection
+    end
+
+    it "should use the same database in the subclass" do
+      parent_class = Class.new do
+        include MarkMapper::Document
+        database = MarkMapper.application.content_databases[0]
+      end
+
+      child_class = Class.new(parent_class) do
+        include MarkMapper::Document
+      end
+
+      child_class.database.should == MarkMapper.application.content_databases[0]
+    end
+
+    it "should use the same collection in the subclass" do
+      DocDaughter.collection.name.should == DocParent.collection.name
+    end
+
+    context "if the subclass changes its collection" do
+      before do
+        class ::DocSCIOrphan < ::DocParent
+          set_collection_name "foobars"
+        end
+      end
+
+      after do
+        Object.send :remove_const, 'DocSCIOrphan'       if defined?(::DocSCIOrphan)
+      end
+
+      it "should negate SCI" do
+        DocSCIOrphan.collection.name.should == "foobars"
+        DocSCIOrphan.should_not be_single_collection_inherited
+      end
+
+      it "should remove the _type key" do
+        DocParent.keys.should_not have_key "_type"
+        DocSCIOrphan.keys.should_not have_key "_type"
+      end
+
+      context "and then is subclassed again" do
+        before do
+          class ::DocSCIOrphanChild < ::DocSCIOrphan
+          end
+        end
+
+        after do
+          Object.send :remove_const, 'DocSCIOrphanChild'  if defined?(::DocSCIOrphanChild)
+        end
+
+        it "should reinstate SCI" do
+          DocSCIOrphan.should_not be_single_collection_inherited
+          DocSCIOrphanChild.should be_single_collection_inherited
+        end
+
+        it "should have the _type key" do
+          DocSCIOrphan.keys.should have_key "_type"
+          DocSCIOrphanChild.keys.should have_key "_type"
+        end
+      end
+    end
+
+    it "should know single_collection_parent" do
+      DocParent.single_collection_parent.should be_nil
+      DocDaughter.single_collection_parent.should      == DocParent
+      DocSon.single_collection_parent.should           == DocParent
+      DocGrandSon.single_collection_parent.should      == DocSon
+      DocGrandGrandSon.single_collection_parent.should == DocGrandSon
+    end
+
+    it "should know single_collection_root" do
+      DocParent.single_collection_root.should        == DocParent
+      DocDaughter.single_collection_root.should      == DocParent
+      DocSon.single_collection_root.should           == DocParent
+      DocGrandSon.single_collection_root.should      == DocParent
+      DocGrandGrandSon.single_collection_root.should == DocParent
+    end
+
+    context ".single_collection_inherited?" do
+      it "should be false if has not inherited" do
+        DocParent.should_not be_single_collection_inherited
+      end
+
+      it "should be true if inherited" do
+        DocDaughter.should be_single_collection_inherited
+        DocSon.should be_single_collection_inherited
+        DocGrandSon.should be_single_collection_inherited
+      end
+    end
+
+    it "should set _type on initialize" do
+      DocDaughter.new._type.should  == 'DocDaughter'
+      DocSon.new._type.should       == 'DocSon'
+      DocGrandSon.new._type.should  == 'DocGrandSon'
+    end
+
+    it "should set _type based on class and ignore assigned values" do
+      DocSon.new(:_type => 'DocDaughter')._type.should == 'DocSon'
+    end
+
+    context "loading" do
+      it "should be based on _type" do
+        @parent.save
+        @daughter.save
+
+        collection = DocParent.all
+        collection.size.should == 2
+        collection.first.should be_kind_of(DocParent)
+        collection.first.name.should == "Daddy Warbucks"
+        collection.last.should be_kind_of(DocDaughter)
+        collection.last.name.should == "Little Orphan Annie"
+      end
+
+      it "should gracefully handle when _type cannot be constantized" do
+        doc = DocParent.new(:name => 'Nunes')
+        doc._type = 'FoobarBaz'
+        doc.save
+
+        collection = DocParent.all
+        collection.last.should == doc
+        collection.last.should be_kind_of(DocParent)
+      end
+    end
+
+    context "querying" do
+      it "should find scoped to class" do
+        john = DocSon.create(:name => 'John')
+        steve = DocSon.create(:name => 'Steve')
+        steph = DocDaughter.create(:name => 'Steph')
+        carrie = DocDaughter.create(:name => 'Carrie')
+        boris = DocGrandSon.create(:name => 'Boris')
+
+        DocGrandGrandSon.all(:order => 'name').should  == []
+        DocGrandSon.all(:order => 'name').should  == [boris]
+        DocSon.all(:order => 'name').should       == [boris, john, steve]
+        DocDaughter.all(:order => 'name').should  == [carrie, steph]
+        DocParent.all(:order => 'name').should    == [boris, carrie, john, steph, steve]
+
+        sigmund = DocGrandGrandSon.create(:name => 'Sigmund')
+
+        DocGrandSon.all(:order => 'name').should  == [boris, sigmund]
+        DocSon.all(:order => 'name').should       == [boris, john, sigmund, steve]
+        DocParent.all(:order => 'name').should    == [boris, carrie, john, sigmund, steph, steve]
+      end
+
+      it "should work with nested hash conditions" do
+        john = DocSon.create(:name => 'John')
+        steve = DocSon.create(:name => 'Steve')
+        DocSon.all(:name => {'$ne' => 'Steve'}).should == [john]
+      end
+
+      it "should raise error if not found scoped to class" do
+        john = DocSon.create(:name => 'John')
+        steph = DocDaughter.create(:name => 'Steph')
+
+        lambda {
+          DocSon.find!(steph._id)
+        }.should raise_error(MarkMapper::DocumentNotFound)
+      end
+
+      it "should not raise error for find with parent" do
+        john = DocSon.create(:name => 'John')
+
+        DocParent.find!(john._id).should == john
+      end
+
+      it "should count scoped to class" do
+        john = DocSon.create(:name => 'John')
+        steve = DocSon.create(:name => 'Steve')
+        steph = DocDaughter.create(:name => 'Steph')
+        carrie = DocDaughter.create(:name => 'Carrie')
+
+        DocGrandSon.count.should  == 0
+        DocSon.count.should       == 2
+        DocDaughter.count.should  == 2
+        DocParent.count.should    == 4
+      end
+
+      it "should not be able to destroy each other" do
+        john = DocSon.create(:name => 'John')
+        steph = DocDaughter.create(:name => 'Steph')
+
+        lambda {
+          DocSon.destroy(steph._id)
+        }.should raise_error(MarkMapper::DocumentNotFound)
+      end
+
+      it "should not be able to delete each other" do
+        john = DocSon.create(:name => 'John')
+        steph = DocDaughter.create(:name => 'Steph')
+
+        lambda {
+          DocSon.delete(steph._id)
+        }.should_not change { DocParent.count }
+      end
+
+      it "should be able to destroy using parent" do
+        john = DocSon.create(:name => 'John')
+        steph = DocDaughter.create(:name => 'Steph')
+
+        lambda {
+          DocParent.destroy_all
+        }.should change { DocParent.count }.by(-2)
+      end
+
+      it "should be able to delete using parent" do
+        john = DocSon.create(:name => 'John')
+        steph = DocDaughter.create(:name => 'Steph')
+
+        lambda {
+          DocParent.delete_all
+        }.should change { DocParent.count }.by(-2)
+      end
+    end
+
+    it "should be able to reload single collection inherited parent class" do
+      brian = DocParent.create(:name => 'Brian')
+      brian.name = 'B-Dawg'
+      brian.reload
+      brian.name.should == 'Brian'
+    end
+  end
+
+  describe "Single collection inheritance (embedded document)" do
+    before do
+      class ::Grandparent
+        include MarkMapper::EmbeddedDocument
+        key :grandparent, String
+      end
+
+      class ::Parent < ::Grandparent
+        include MarkMapper::EmbeddedDocument
+        key :parent, String
+      end
+
+      class ::Child < ::Parent
+        include MarkMapper::EmbeddedDocument
+        key :child, String
+      end
+
+      class ::OtherChild < ::Parent
+        include MarkMapper::EmbeddedDocument
+        key :other_child, String
+      end
+    end
+
+    after do
+      Object.send :remove_const, 'Grandparent' if defined?(::Grandparent)
+      Object.send :remove_const, 'Parent'      if defined?(::Parent)
+      Object.send :remove_const, 'Child'       if defined?(::Child)
+      Object.send :remove_const, 'OtherChild'  if defined?(::OtherChild)
+    end
+
+    it "should automatically add _type key" do
+      Grandparent.key?(:_type).should be_truthy
+    end
+
+    context ".single_collection_inherited?" do
+      it "should be false if has not inherited" do
+        Grandparent.should_not be_single_collection_inherited
+      end
+
+      it "should be true if inherited" do
+        Parent.should be_single_collection_inherited
+        Child.should be_single_collection_inherited
+        OtherChild.should be_single_collection_inherited
+      end
+    end
+
+    it "should set _type on initialize" do
+      Parent.new._type.should     == 'Parent'
+      Child.new._type.should      == 'Child'
+      OtherChild.new._type.should == 'OtherChild'
+    end
+
+    it "should set _type based on class and ignore assigned values" do
+      Child.new(:_type => 'OtherChild')._type.should == 'Child'
+    end
+  end
+
+  describe "With polymorphism" do
+    before :all do
+      class SciPolymorphicPost
+        include MarkMapper::Document
+        belongs_to :article_parent, :polymorphic => true
+      end
+
+      class GalleryItem
+        include MarkMapper::Document
+        belongs_to :gallery_album
+        key :text, Hash
+        timestamps!
+      end
+
+      class TextGalleryItem < GalleryItem;
+        many :sci_polymorphic_posts, :as => :article_parent
+      end
+    end
+
+    it "should find polymorphic SCI items" do
+      item = TextGalleryItem.new()
+      p = SciPolymorphicPost.create(:article_parent => item)
+      p.article_parent_id.should be_a MarkLogic::ObjectId
+      p.article_parent_type.should == "TextGalleryItem"
+
+      p.reload.article_parent.sci_polymorphic_posts.all.should include(p)
+    end
+  end
+end

data/spec/functional/scopes_spec.rb

@@ -0,0 +1,204 @@
+require 'spec_helper'
+
+describe "Scopes" do
+  context "Scopes" do
+    before do
+      @document = Doc() do
+        key :name, String
+        key :age, Integer
+        timestamps!
+      end
+    end
+
+    context "basic scopes" do
+      before do
+        @document.class_eval do
+          scope :old, :age.gt => 60
+          scope :teens, :age.ge => 13, :age.le => 19
+        end
+      end
+
+      it "should know what scopes have been added" do
+        @document.scopes.size.should == 2
+        @document.scopes.keys.map(&:to_s).sort.should == %w(old teens)
+      end
+
+      it "should return a query" do
+        @document.old.should be_kind_of(MarkMapper::Query)
+      end
+
+      it "should work" do
+        @document.create(:name => 'John', :age => 99)
+        @document.create(:name => 'Frank', :age => 15)
+        docs = @document.old.all
+        docs.size.should == 1
+        docs[0].name.should == 'John'
+      end
+
+      # Regression test for #534
+      context "when where() is invoked via a scope before a key is defined" do
+        let(:given_id) { MarkLogic::ObjectId.new }
+        let(:doc) { Doc {
+           key :type, String
+
+           # Ordering is important here; where needs to happen before foo_id is defined
+           # in order to produce the behavior we're testing against regression.
+           scope :type, where(:type => "bar")
+           key :foo_id, ObjectId
+        }}
+        before {
+          doc.collection.drop
+          doc.create({:foo_id => given_id})
+        }
+
+        it "should work without typecasts" do
+          doc.where(:foo_id => given_id).count.should == 1
+        end
+
+        it "should work with typecasts" do
+          doc.where(:foo_id => given_id.to_s).count.should == 1
+        end
+      end
+    end
+
+    context "dynamic scopes" do
+      before do
+        @document.class_eval do
+          scope :age,     lambda { |age| {:age => age} }
+          scope :ages,    lambda { |low, high| {:age.ge => low, :age.le => high} }
+          scope :ordered, lambda { |sort| sort(sort) }
+        end
+      end
+
+      it "should work with single argument" do
+        @document.create(:name => 'John', :age => 60)
+        @document.create(:name => 'Frank', :age => 50)
+        docs = @document.age(60).all
+        docs.size.should == 1
+        docs.first.name.should == 'John'
+      end
+
+      it "should work with multiple arguments" do
+        @document.create(:name => 'John', :age => 60)
+        @document.create(:name => 'Frank', :age => 50)
+        @document.create(:name => 'Bill', :age => 40)
+        docs = @document.ages(50, 70).all
+        docs.size.should == 2
+        docs.map(&:name).sort.should == %w(Frank John)
+      end
+
+      it "should work with queries" do
+        john  = @document.create(:name => 'John', :age => 60)
+        frank = @document.create(:name => 'Frank', :age => 50)
+        bill  = @document.create(:name => 'Bill', :age => 40)
+        @document.ordered(:age).all.should == [bill, frank, john]
+      end
+    end
+
+    context "query scopes" do
+      before do
+        @document.class_eval do
+          scope :boomers, where(:age.ge => 60).sort(:age)
+        end
+      end
+
+      it "should work" do
+        todd = @document.create(:name => 'Todd', :age => 65)
+        john = @document.create(:name => 'John', :age => 60)
+        @document.create(:name => 'Frank', :age => 50)
+        @document.create(:name => 'Bill', :age => 40)
+        docs = @document.boomers.all
+        docs[0].should == john
+        docs[1].should == todd
+      end
+    end
+
+    context "chaining" do
+      before do
+        @document.class_eval do
+          scope :by_age,  lambda { |age| {:age => age} }
+          scope :by_name, lambda { |name| {:name => name} }
+        end
+      end
+
+      it "should work with scope methods" do
+        @document.create(:name => 'John', :age => 60)
+        @document.create(:name => 'Frank', :age => 60)
+        @document.create(:name => 'Bill', :age => 50)
+        docs = @document.by_age(60).by_name('John').all
+        docs.size.should == 1
+        docs.first.name.should == 'John'
+      end
+
+      it "should work on query methods" do
+        @document.create(:name => 'John', :age => 60)
+        @document.create(:name => 'John', :age => 50)
+        @document.create(:name => 'Bill', :age => 50)
+        docs = @document.where(:name => 'John').by_age(50).all
+        docs.size.should == 1
+        docs.first.age.should == 50
+      end
+
+      context "with model methods" do
+        it "should work if method returns a query" do
+          @document.create(:name => 'John', :age => 10)
+          @document.create(:name => 'John', :age => 20)
+          @document.class_eval do
+            def self.young
+              query(:age.le => 12)
+            end
+          end
+          docs = @document.by_name('John').young.all
+          docs.size.should == 1
+          docs.first.age.should == 10
+        end
+
+        it "should not work if method does not return a query" do
+          @document.class_eval { def self.age; 20 end }
+          @document.by_name('John').age.should == 20
+        end
+      end
+    end
+
+    context "with single collection inheritance" do
+      before do
+        class ::Item
+          include MarkMapper::Document
+          scope :by_title,  lambda { |title| {:title => title} }
+          scope :published, lambda { {:published_at.le => Time.now.utc} }
+
+          key   :title, String
+          key   :published_at, Time
+        end
+        Item.collection.remove
+
+        class ::Page < ::Item; end
+        class ::Blog < ::Item
+          key :slug, String
+          scope :by_slug, lambda { |slug| {:slug => slug} }
+        end
+      end
+
+      after do
+        Object.send :remove_const, 'Item' if defined?(::Item)
+        Object.send :remove_const, 'Page' if defined?(::Page)
+        Object.send :remove_const, 'Blog' if defined?(::Blog)
+      end
+
+      it "should inherit scopes" do
+        Page.scopes.keys.map(&:to_s).sort.should == %w(by_title published)
+      end
+
+      it "should work with _type" do
+        item = Item.create(:title => 'Home')
+        page = Page.create(:title => 'Home')
+        Page.by_title('Home').first.should == page
+      end
+
+      it "should limit subclass scopes to subclasses" do
+        Item.scopes.keys.map(&:to_s).should =~ %w(by_title published)
+        Blog.scopes.keys.map(&:to_s).should =~ %w(by_slug by_title published)
+      end
+    end
+  end
+end