mark_mapper 0.0.1

data/spec/unit/clone_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe "Clone" do
+  context "Document" do
+    before do
+      @document = Doc()
+      @embedded = EDoc()
+      @document.many :widgets, :class => @embedded
+      @tags = ['red', 'green', 'blue']
+      @doc = @document.create({
+        :name    => "foo",
+        :age     => 27,
+        :tags    => @tags,
+        :widgets => [@embedded.new, @embedded.new],
+      })
+    end
+
+    context "#clone" do
+      it "should be new" do
+        @doc.clone.should be_new
+      end
+
+      it "should copy the attributes" do
+        clone = @doc.clone
+        clone.name.should == "foo"
+        clone.age.should == 27
+      end
+
+      it "should clone duplicable attributes" do
+        @doc.clone.tags.should_not equal(@tags)
+      end
+
+      it "should clone many embedded documents" do
+        @doc.clone.widgets.object_id.should_not equal(@doc.widgets.object_id)
+      end
+
+      it "should not be destroyed" do
+        @doc.destroy
+        @doc.clone.should_not be_destroyed
+      end
+
+      it "should generate a new id" do
+        @doc.clone.id.should_not be_nil
+        @doc.clone.id.should_not equal(@doc.id)
+      end
+
+      it "should clone a cloned document" do
+        expect { @doc.clone.clone }.to_not raise_error
+        @doc.clone.clone.id.should be_a MarkLogic::ObjectId
+      end
+    end
+  end
+
+  context "EmbeddedDocument" do
+    before do
+      @document = EDoc do
+        key :name, String
+        key :age, Integer
+      end
+    end
+
+    context "#clone" do
+      it "should regenerate the id" do
+        doc = @document.new(:name => "foo", :age => 27)
+        doc_id = doc.id
+        clone = doc.clone
+        clone_id = clone.id
+        clone_id.should_not == doc_id
+      end
+
+      it "should copy the attributes" do
+        doc = @document.new(:name => "foo", :age => 27)
+        clone = doc.clone
+        clone.name.should == "foo"
+        clone.age.should == 27
+      end
+    end
+  end
+end

data/spec/unit/config_generator_spec.rb

@@ -0,0 +1,24 @@
+# require 'spec_helper'
+# require 'rails/generators'
+# require 'rails/generators/test_case'
+# require 'rails/generators/mark_mapper/config/config_generator'
+
+# describe MarkMapper::Generators::ConfigGenerator do
+#   include GeneratorSpec::TestCase
+
+#   destination File.expand_path('../../tmp', File.dirname(__FILE__))
+#   before do
+#     prepare_destination
+#   end
+
+#   it 'marklogic.yml are properly created' do
+#     run_generator
+#     assert_file 'config/marklogic.yml', /#{File.basename(destination_root)}/
+#   end
+
+#   it 'marklogic.yml are properly created with defined database_name' do
+#     run_generator %w{dummy}
+#     assert_file 'config/marklogic.yml', /dummy/
+#   end
+
+# end

data/spec/unit/criteria_hash_spec.rb

@@ -0,0 +1,218 @@
+require 'spec_helper'
+require 'securerandom'
+
+describe MarkMapper::CriteriaHash do
+  context "#initialize_copy" do
+    before do
+      @original = described_class.new({
+        :comments => {:_id => 1}, :tags => ['marklogic', 'ruby'],
+      }, :object_ids => [:_id])
+      @cloned   = @original.clone
+    end
+
+    it "duplicates source hash" do
+      @cloned.source.should_not equal(@original.source)
+    end
+
+    it "duplicates options hash" do
+      @cloned.options.should_not equal(@original.options)
+    end
+
+    it "clones duplicable? values" do
+      @cloned[:comments].should_not equal(@original[:comments])
+      @cloned[:tags].should_not equal(@original[:tags])
+    end
+  end
+
+  context "#object_ids=" do
+    it "works with array" do
+      criteria = described_class.new
+      criteria.object_ids = [:_id]
+      criteria.object_ids.should == [:_id]
+    end
+
+    it "flattens multi-dimensional array" do
+      criteria = described_class.new
+      criteria.object_ids = [[:_id]]
+      criteria.object_ids.should == [:_id]
+    end
+
+    it "raises argument error if not array" do
+      expect { described_class.new.object_ids = {} }.to raise_error(ArgumentError)
+      expect { described_class.new.object_ids = nil }.to raise_error(ArgumentError)
+      expect { described_class.new.object_ids = 'foo' }.to raise_error(ArgumentError)
+    end
+  end
+
+  context "#[]=" do
+    context "with key and value" do
+      let(:key_normalizer)   { lambda { |*args| :normalized_key    } }
+      let(:value_normalizer) { lambda { |*args| 'normalized_value' } }
+
+      it "sets normalized key to normalized value in source" do
+        criteria = described_class.new({}, :value_normalizer => value_normalizer, :key_normalizer => key_normalizer)
+        criteria[:foo] = 'bar'
+        criteria.source[:normalized_key].should eq('normalized_value')
+      end
+    end
+
+    context "with conditions" do
+      it "sets each of conditions keys in source" do
+        criteria = described_class.new
+        criteria[:conditions] = {:_id => 'john', :foo => 'bar'}
+        criteria.source[:_id].should eq('john')
+        criteria.source[:foo].should eq('bar')
+      end
+    end
+
+    context "with symbol operators" do
+      it "sets nests key with operator and value" do
+        criteria = described_class.new
+        criteria[:age.gt] = 20
+        criteria[:age.lt] = 10
+        criteria.source[:age].should eq({:$gt => 20, :$lt => 10})
+      end
+    end
+  end
+
+  context "#merge" do
+    it "works when no keys match" do
+      c1 = described_class.new(:foo => 'bar')
+      c2 = described_class.new(:baz => 'wick')
+      c1.merge(c2).source.should eq(:foo => 'bar', :baz => 'wick')
+    end
+
+    it "turns matching keys with simple values into array" do
+      c1 = described_class.new(:foo => 'bar')
+      c2 = described_class.new(:foo => 'baz')
+      c1.merge(c2).source.should eq(:foo => {:$eq => %w[bar baz]})
+    end
+
+    it "uniques matching key values" do
+      c1 = described_class.new(:foo => 'bar')
+      c2 = described_class.new(:foo => 'bar')
+      c1.merge(c2).source.should eq(:foo => {:$eq => %w[bar]})
+    end
+
+    it "correctly merges arrays and non-arrays" do
+      c1 = described_class.new(:foo => 'bar')
+      c2 = described_class.new(:foo => %w[bar baz])
+      c1.merge(c2).source.should eq(:foo => {:$eq => %w[bar baz]})
+      c2.merge(c1).source.should eq(:foo => {:$eq => %w[bar baz]})
+    end
+
+    it "correctly merges two bson object ids" do
+      id1 = SecureRandom.hex
+      id2 = SecureRandom.hex
+      c1 = described_class.new(:foo => id1)
+      c2 = described_class.new(:foo => id2)
+      c1.merge(c2).source.should eq(:foo => {:$eq => [id1, id2]})
+    end
+
+    it "correctly merges array and an object id" do
+      id1 = SecureRandom.hex
+      id2 = SecureRandom.hex
+      c1 = described_class.new(:foo => [id1])
+      c2 = described_class.new(:foo => id2)
+      c1.merge(c2).source.should eq(:foo => {:$eq => [id1, id2]})
+      c2.merge(c1).source.should eq(:foo => {:$eq => [id1, id2]})
+    end
+
+    it "is able to merge two modifier hashes" do
+      c1 = described_class.new(:$eq => [1, 2])
+      c2 = described_class.new(:$eq => [2, 3])
+      c1.merge(c2).source.should eq(:$eq => [1, 2, 3])
+    end
+
+    it "is able to merge two modifier hashes with hash values" do
+      c1 = described_class.new(:arr => {:$elemMatch => {:foo => 'bar'}})
+      c2 = described_class.new(:arr => {:$elemMatch => {:omg => 'ponies'}})
+      c1.merge(c2).source.should eq(:arr => {:$elemMatch => {:foo => 'bar', :omg => 'ponies'}})
+    end
+
+    it "merges matching keys with a single modifier" do
+      c1 = described_class.new(:foo => {:$eq => [1, 2, 3]})
+      c2 = described_class.new(:foo => {:$eq => [1, 4, 5]})
+      c1.merge(c2).source.should eq(:foo => {:$eq => [1, 2, 3, 4, 5]})
+    end
+
+    it "merges matching keys with multiple modifiers" do
+      c1 = described_class.new(:foo => {:$eq => [1, 2, 3]})
+      c2 = described_class.new(:foo => {:$all => [1, 4, 5]})
+      c1.merge(c2).source.should eq(:foo => {:$eq => [1, 2, 3], :$all => [1, 4, 5]})
+    end
+
+    it "does not update mergee" do
+      c1 = described_class.new(:foo => 'bar')
+      c2 = described_class.new(:foo => 'baz')
+      c1.merge(c2).should_not equal(c1)
+      c1[:foo].should == 'bar'
+    end
+
+    context "given multiple $or clauses" do
+      before do
+        @c1 = described_class.new(:$or => [{:a => 1}, {:b => 2}])
+        @c2 = described_class.new(:$or => [{:a => 3}, {:b => 4}])
+        @c3 = described_class.new(:$or => [{:a => 4}, {:b => 4}])
+      end
+
+      it "merges two $ors into a compound $and" do
+        merged = @c1.merge(@c2)
+        merged[:$and].should == [
+          {:$or => [{:a => 1}, {:b => 2}]},
+          {:$or => [{:a => 3}, {:b => 4}]}
+        ]
+      end
+
+      it "merges an $and and a $or into a compound $and" do
+        merged = @c1.merge(@c2).merge(@c3)
+        merged[:$and].should == [
+          {:$or => [{:a => 1}, {:b => 2}]},
+          {:$or => [{:a => 3}, {:b => 4}]},
+          {:$or => [{:a => 4}, {:b => 4}]}
+        ]
+      end
+
+      it "merges an $or and an $and into a compound $and" do
+        merged = @c3.merge @c1.merge(@c2)
+        merged[:$and].should == [
+          {:$or => [{:a => 1}, {:b => 2}]},
+          {:$or => [{:a => 3}, {:b => 4}]},
+          {:$or => [{:a => 4}, {:b => 4}]}
+        ]
+      end
+    end
+  end
+
+  context "#merge!" do
+    it "updates mergee" do
+      c1 = described_class.new(:foo => 'bar')
+      c2 = described_class.new(:foo => 'baz')
+      c1.merge!(c2).should equal(c1)
+      c1[:foo].should == {:$eq => ['bar', 'baz']}
+    end
+  end
+
+  context "#simple?" do
+    it "returns true if only filtering by _id" do
+      described_class.new(:_id => 'id').should be_simple
+    end
+
+    it "returns true if only filtering by Sci" do
+      described_class.new(:_id => 'id', :_type => 'Foo').should be_simple
+      described_class.new(:_type => 'Foo', :_id => 'id').should be_simple # reverse order
+    end
+
+    it "returns false if querying by more than max number of simple keys" do
+      described_class.new(:one => 1, :two => 2, :three => 3).should_not be_simple
+    end
+
+    it "returns false if querying by anthing other than _id/Sci" do
+      described_class.new(:foo => 'bar').should_not be_simple
+    end
+
+    it "returns false if querying only by _type" do
+      described_class.new(:_type => 'Foo').should_not be_simple
+    end
+  end
+end

data/spec/unit/document_spec.rb

@@ -0,0 +1,251 @@
+require 'spec_helper'
+
+
+describe "Document" do
+  context "The Document Class" do
+    before do
+      @document = Doc()
+    end
+
+    it "should return false for embeddable" do
+      Doc().embeddable?.should be_falsey
+    end
+
+    it "should have logger method" do
+      @document.logger.should == MarkMapper.logger
+      @document.logger.should be_instance_of(Logger)
+    end
+
+    it "should use default database by default" do
+      @document.database.should == MarkMapper.application.content_databases[0]
+    end
+
+    it "should have a connection" do
+      @document.connection.should be_instance_of(MarkLogic::Connection)
+    end
+
+    it "should allow setting different connection without affecting the default" do
+      conn = MarkLogic::Connection.new(HOST, PORT)
+      @document.connection conn
+      @document.connection.should be conn
+      @document.connection.should_not be MarkMapper.connection
+    end
+
+    it "should allow setting a different database without affecting the default" do
+      db = MarkLogic::Database.new('test2', CONNECTION)
+      @document.database = db
+      @document.database.should == db
+      @document.database_name.should == 'test2'
+      @document.database.database_name.should == 'test2'
+
+      another_document = Doc()
+      another_document.database.database_name.should == MarkMapper.application.content_databases[0].database_name
+    end
+
+    it "should allow setting the collection name" do
+      @document.set_collection_name('foobar')
+      @document.collection.name.should == 'foobar'
+    end
+
+    context ".collection" do
+      it "should default collection name to class name tableized" do
+        class ::Item
+          include MarkMapper::Document
+        end.collection.name.should == 'items'
+      end
+
+      it "should default collection name of namespaced class to tableized with dot separation" do
+        module ::BloggyPoo
+          class Post
+            include MarkMapper::Document
+          end.collection.name.should == 'bloggy_poo.posts'
+        end
+      end
+
+      it "should be an instance of a MarkLogic::Collection" do
+        @document.collection.should be_instance_of(MarkLogic::Collection)
+      end
+    end
+  end # Document class
+
+  context "Documents that inherit from other documents" do
+    it "should default collection name to inherited class" do
+      Message.collection_name.should == 'messages'
+      Enter.collection_name.should   == 'messages'
+      Exit.collection_name.should    == 'messages'
+      Chat.collection_name.should    == 'messages'
+    end
+
+    it "should default associations to inherited class" do
+      Message.associations.keys.should include(:room)
+      Enter.associations.keys.should   include(:room)
+      Exit.associations.keys.should    include(:room)
+      Chat.associations.keys.should    include(:room)
+    end
+  end
+
+  context "descendants" do
+    it "should default to an empty array" do
+      Enter.descendants.should == []
+    end
+
+    it "should be recorded" do
+      Message.descendants.should == [Enter, Exit, Chat]
+    end
+  end
+
+  context "An instance of a document" do
+    before do
+      @document = Doc do
+        key :name, String
+        key :age, Integer
+      end
+    end
+
+    it "should respond to cache_key" do
+      @document.new.should respond_to(:cache_key)
+    end
+
+    it "should create id during initialization" do
+      @document.new._id.should be_instance_of(MarkLogic::ObjectId)
+    end
+
+    it "should have access to logger" do
+      doc = @document.new
+      doc.logger.should == @document.logger
+      doc.logger.should be_instance_of(Logger)
+    end
+
+    it "should have access to the class's collection" do
+      doc = @document.new
+      doc.collection.name.should == @document.collection.name
+    end
+
+    it "should use default values if defined for keys" do
+      @document.key :active, Boolean, :default => true
+
+      @document.new.active.should be_truthy
+      @document.new(:active => false).active.should be_falsey
+    end
+
+    it "should use default values if defined even when custom data type" do
+      @document.key :window, WindowSize, :default => WindowSize.new(600, 480)
+
+      doc = @document.new
+      doc.window.should == WindowSize.new(600, 480)
+    end
+
+    context "root document" do
+      it "should set self to the root document on embedded documents" do
+        klass = Doc()
+        pets = EDoc()
+
+        klass.many :pets, :class => pets
+
+        doc = klass.new(:pets => [{}])
+        doc.pets.first._root_document.should == doc
+      end
+    end
+
+    context "new?" do
+      it "should be true if no id" do
+        @document.new.new?.should be_truthy
+      end
+
+      it "should be true if id but using custom id and not saved yet" do
+        @document.key :_id, String
+        doc = silence_stderr { @document.new }
+        doc.id = '1234'
+        doc.new?.should be_truthy
+      end
+    end
+
+    context "equality" do
+      before do
+        @oid = MarkLogic::ObjectId.new
+      end
+
+      it "should delegate hash to _id" do
+        doc = @document.new
+        doc.hash.should == doc._id.hash
+      end
+
+      it "should delegate eql to ==" do
+        doc = @document.new
+        other = @document.new
+        doc.eql?(other).should == (doc == other)
+        doc.eql?(doc).should == (doc == doc)
+      end
+
+      it "should know if same object as another" do
+        doc = @document.new
+        doc.should equal(doc)
+        doc.should_not equal(@document.new)
+      end
+
+      it "should allow set operations on array of documents" do
+        @document.key :parent_id, ObjectId
+        @document.belongs_to :parent, :class => @document
+
+        parent = @document.create
+        child = @document.create(:parent => parent)
+
+        ([child.parent] & [parent]).should == [parent]
+      end
+
+      it "should be equal if id and class are the same" do
+        (@document.new('_id' => @oid) == @document.new('_id' => @oid)).should be(true)
+      end
+
+      it "should not be equal if class same but id different" do
+        (@document.new('_id' => @oid) == @document.new('_id' => MarkLogic::ObjectId.new)).should be(false)
+      end
+
+      it "should not be equal if id same but class different" do
+        another_document = Doc()
+        (@document.new('_id' => @oid) == another_document.new('_id' => @oid)).should be(false)
+      end
+    end
+
+    context "nil attributes" do
+
+      it "should list all the keys and default non nil attributes" do
+       doc = @document.new
+       doc.keys.keys.sort.should == ['_id', 'age', 'name']
+       doc.attributes.keys.sort.should == ['_id']
+      end
+
+      it "should list all the keys and non nil attributes" do
+       doc = @document.new(:name => "John")
+       doc.keys.keys.sort.should == ['_id', 'age', 'name']
+       doc.attributes.keys.sort.should == ['_id','name']
+      end
+
+      it "should list all the keys and pickup changed nil attributes" do
+       doc = @document.new(:name => "John")
+       doc.keys.keys.sort.should == ['_id', 'age', 'name']
+       doc.attributes.keys.sort.should == ['_id','name']
+
+       doc.name = nil
+
+       doc.keys.keys.sort.should == ['_id', 'age', 'name']
+       doc.attributes.keys.sort.should == ['_id']
+      end
+
+      it "should list all the keys and pickup changed nil and non-nil attributes" do
+       doc = @document.new(:name => "John")
+       doc.keys.keys.sort.should == ['_id', 'age', 'name']
+       doc.attributes.keys.sort.should == ['_id','name']
+
+       doc.name = nil
+       doc.age = 12
+
+       doc.keys.keys.sort.should == ['_id', 'age', 'name']
+       doc.attributes.keys.sort.should == ['_id','age']
+      end
+
+    end
+
+  end # instance of a document
+end # DocumentTest
+