mark_mapper 0.0.1

data/spec/unit/rails_compatibility_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe "Rails Compatibility" do
+  module EmbeddedDocuments
+    class Item
+      include MarkMapper::EmbeddedDocument
+      key :for_all, String
+    end
+
+    class FirstItem < Item
+      key :first_only, String
+      many :second_items
+    end
+
+    class SecondItem < Item
+      key :second_only, String
+    end
+  end
+
+  context "EmbeddedDocument" do
+    it "should alias many to has_many" do
+      EmbeddedDocuments::FirstItem.should respond_to(:has_many)
+    end
+
+    it "should alias one to has_one" do
+      EmbeddedDocuments::FirstItem.should respond_to(:has_one)
+    end
+
+    it "should have column names" do
+      EmbeddedDocuments::Item.column_names.sort.should == ['_id', '_type', 'for_all']
+      EmbeddedDocuments::FirstItem.column_names.sort.should == ['_id', '_type', 'first_only', 'for_all']
+      EmbeddedDocuments::SecondItem.column_names.sort.should == ['_id', '_type', 'for_all', 'second_only']
+    end
+
+    it "should alias new to new_record?" do
+      instance = EmbeddedDocuments::Item.new
+      instance.new_record?.should == instance.new?
+    end
+  end
+end

data/spec/unit/rails_reflect_on_association_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+module ReflectOnAssociationTestModels
+  class Tree
+    include MarkMapper::Document
+    many :birds, :class_name => "ReflectOnAssociationTestModels::Bird"
+  end
+
+  class Bird
+    include MarkMapper::Document
+    belongs_to :tree, :class_name => "ReflectOnAssociationTestModels::Tree"
+  end
+
+  class Book
+    include MarkMapper::Document
+    many :authors, :class_name => "ReflectOnAssociationTestModels::Author", :in => :author_ids
+  end
+
+  class Author
+    include MarkMapper::Document
+  end
+
+  class Employee
+    include MarkMapper::Document
+    one :desk, :class_name => "ReflectOnAssociationTestModels::Desk"
+  end
+
+  class Desk
+    include MarkMapper::Document
+    belongs_to :employee, :class_name => "ReflectOnAssociationTestModels::Employee"
+  end
+
+  class Order
+    include MarkMapper::Document
+    many :line_items, :class_name => "ReflectOnAssociationTestModels::LineItem"
+  end
+
+  class LineItem
+    include MarkMapper::EmbeddedDocument
+  end
+
+  class Body
+    include MarkMapper::Document
+    one :heart, :class_name => "ReflectOnAssociationTestModels::Heart"
+  end
+
+  class Heart
+    include MarkMapper::EmbeddedDocument
+  end
+end
+
+describe "ReflectOnAssociation" do
+  context "one-to-many association" do
+    it "should return :has_many association for Tree#birds" do
+      association = ReflectOnAssociationTestModels::Tree.reflect_on_association(:birds)
+      association.klass.should == ReflectOnAssociationTestModels::Bird
+      association.macro.should == :has_many
+      association.name.should == :birds
+      association.options.should == {}
+    end
+
+    it "should return :belongs_to association for Bird#tree" do
+      association = ReflectOnAssociationTestModels::Bird.reflect_on_association(:tree)
+      association.klass.should == ReflectOnAssociationTestModels::Tree
+      association.macro.should == :belongs_to
+      association.name.should == :tree
+      association.options.should == {}
+    end
+  end
+
+  context "many-to-many association" do
+    it "should return :has_many association for Book#authors" do
+      association = ReflectOnAssociationTestModels::Book.reflect_on_association(:authors)
+      association.klass.should == ReflectOnAssociationTestModels::Author
+      association.macro.should == :has_many
+      association.name.should == :authors
+      association.options.should == {}
+    end
+  end
+
+  context "one-to-one association" do
+    it "should return :has_one association for Employee#desk" do
+      association = ReflectOnAssociationTestModels::Employee.reflect_on_association(:desk)
+      association.klass.should == ReflectOnAssociationTestModels::Desk
+      association.macro.should == :has_one
+      association.name.should == :desk
+      association.options.should == {}
+    end
+
+    it "should return :belongs_to association for Desk#employee" do
+      association = ReflectOnAssociationTestModels::Desk.reflect_on_association(:employee)
+      association.klass.should == ReflectOnAssociationTestModels::Employee
+      association.macro.should == :belongs_to
+      association.name.should == :employee
+      association.options.should == {}
+    end
+  end
+
+  context "embeds one" do
+    it "should return :has_one association for Body#heart" do
+      association = ReflectOnAssociationTestModels::Body.reflect_on_association(:heart)
+      association.klass.should == ReflectOnAssociationTestModels::Heart
+      association.macro.should == :has_one
+      association.name.should == :heart
+      association.options.should == {}
+    end
+  end
+
+  context "embeds many" do
+    it "should return :has_many association for Order#line_items" do
+      association = ReflectOnAssociationTestModels::Order.reflect_on_association(:line_items)
+      association.klass.should == ReflectOnAssociationTestModels::LineItem
+      association.macro.should == :has_many
+      association.name.should == :line_items
+      association.options.should == {}
+    end
+  end
+end

data/spec/unit/rails_spec.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+describe "Rails integration" do
+  context "Document" do
+    before do
+      @klass = Doc('Post') do
+        key :foo, String
+      end
+    end
+
+    context "Class methods" do
+      it "should alias has_many to many" do
+        @klass.should respond_to(:has_many)
+      end
+
+      it 'should pass on block given in has_many' do
+        @klass.class_eval do
+          has_many :posts do
+            def foo_bars; true; end
+          end
+        end
+
+        expect(@klass.new.posts.respond_to?(:foo_bars)).to eq(true)
+      end
+
+      it "should alias has_one to one" do
+        @klass.should respond_to(:has_one)
+      end
+
+      it "should have column names" do
+        @klass.column_names.sort.should == ['_id', 'foo']
+      end
+    end
+
+    context "Instance methods" do
+      before do
+        @klass.class_eval do
+          def bar=(value)
+            write_attribute(:foo, value)
+          end
+
+          def bar_before_type_cast
+            read_attribute_before_type_cast(:foo)
+          end
+
+          def bar
+            read_attribute(:foo)
+          end
+        end
+      end
+
+      it "should alias new_record? to new?" do
+        @klass.new.should be_new_record
+      end
+
+      it "should be able to read key with read_attribute" do
+        @klass.new(:foo => 'Bar').bar.should == 'Bar'
+      end
+
+      it "should be able to read key before type cast with read_attribute_before_type_cast" do
+        @klass.new(:foo => 21).bar_before_type_cast.should == 21
+        @klass.new(:foo => 21).bar.should == '21'
+      end
+
+      it "should be able to write key with write_attribute" do
+        @klass.new(:bar => 'Setting Foo').foo.should == 'Setting Foo'
+      end
+
+      it "should return the type casted value from write attribute" do
+        obj = @klass.new
+        obj.write_attribute(:foo, true).should == "true"
+      end
+
+      context '#to_param' do
+        it "should be nil if not persisted" do
+          @klass.new.tap do |doc|
+            doc.to_param.should be_nil
+          end
+        end
+
+        it "should array representation of id if persisted" do
+          @klass.create.tap do |doc|
+            doc.to_param.should == doc.id.to_s
+          end
+        end
+      end
+
+      context '#to_key' do
+        it "should be nil if not persisted" do
+          @klass.new.tap do |doc|
+            doc.to_key.should be_nil
+          end
+        end
+
+        it "should array representation of id if persisted" do
+          @klass.create.tap do |doc|
+            doc.to_key.should == [doc.id]
+          end
+        end
+      end
+    end
+  end
+
+  context "EmbeddedDocument" do
+    before do
+      @klass = EDoc('Post') { key :foo, String }
+    end
+
+    context "Class methods" do
+      it "should alias has_many to many" do
+        @klass.should respond_to(:has_many)
+      end
+
+      it "should alias has_one to one" do
+        @klass.should respond_to(:has_one)
+      end
+
+      it "should have column names" do
+        @klass.column_names.sort.should == ['_id', 'foo']
+      end
+    end
+
+    context "Instance methods" do
+      before do
+        @klass.class_eval do
+          def bar=(value)
+            write_attribute(:foo, value)
+          end
+
+          def bar_before_type_cast
+            read_attribute_before_type_cast(:foo)
+          end
+
+          def bar
+            read_attribute(:foo)
+          end
+        end
+      end
+
+      it "should alias new_record? to new?" do
+        @klass.new.should be_new_record
+      end
+
+      it "should be able to read key with read_attribute" do
+        @klass.new(:foo => 'Bar').bar.should == 'Bar'
+      end
+
+      it "should be able to read key before type cast with read_attribute_before_type_cast" do
+        @klass.new(:foo => 21).bar_before_type_cast.should == 21
+        @klass.new(:foo => 21).bar.should == '21'
+      end
+
+      it "should be able to write key with write_attribute" do
+        @klass.new(:bar => 'Setting Foo').foo.should == 'Setting Foo'
+      end
+
+      context '#to_param' do
+        it "should be nil if not persisted" do
+          @klass.new.tap do |doc|
+            doc.to_param.should be_nil
+          end
+        end
+
+        it "should array representation of id if persisted" do
+          @klass.new.tap do |doc|
+            expect(doc).to receive(:persisted?).and_return(true)
+            doc.to_param.should == doc.id.to_s
+          end
+        end
+      end
+
+      context '#to_key' do
+        it "should be nil if not persisted" do
+          @klass.new.tap do |doc|
+            doc.to_key.should be_nil
+          end
+        end
+
+        it "should array representation of id if persisted" do
+          @klass.new.tap do |doc|
+            expect(doc).to receive(:persisted?).and_return(true)
+            doc.to_key.should == [doc.id]
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/serialization_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+module Serialization
+  class List
+    include MarkMapper::Document
+    key :name
+    many :items,          :class_name => 'Serialization::Item'
+    belongs_to :creator,  :class_name => 'Serialization::User'
+  end
+
+  class Assignment
+    include MarkMapper::EmbeddedDocument
+    belongs_to :assigned_by,  :class_name => 'Serialization::User'
+    belongs_to :user,         :class_name => 'Serialization::User'
+
+    def serializable_hash(options = {})
+      super({:only => :user_id}.merge(options))
+    end
+  end
+
+  class Item
+    include MarkMapper::Document
+
+    key :title
+    key :description
+    many :assignments, :class_name => 'Serialization::Assignment'
+
+    def a_method
+      1
+    end
+  end
+
+
+  class User
+    include MarkMapper::Document
+    key :name, String
+  end
+
+  describe "Serialization" do
+    before do
+      @document = EDoc do
+        key :name, String
+        key :age, Integer
+        key :awesome, Boolean
+        key :preferences, Hash
+        key :created_at, Time
+      end
+
+      @instance = @document.new(
+        :name        => 'John Doe',
+        :age         => 25,
+        :awesome     => true,
+        :preferences => {:language => 'Ruby'},
+        :created_at  => Time.now.change(:usec => 0)
+      )
+    end
+
+    context "#serializable_hash" do
+      before do
+        @user1 = User.new(:name => 'Brandon')
+        @user2 = User.new(:name => 'John')
+        @item = Item.new(
+          :title => 'Serialization',
+          :description => 'Make it work like magic!',
+          :assignments => [
+            Assignment.new(:assigned_by => @user1, :user => @user2)
+          ]
+        )
+      end
+
+      it "should only include specified attributes with :only option" do
+        @item.serializable_hash(:only => :title).should == {'title' => 'Serialization'}
+      end
+
+      it "should exclude attributes specified with :except option" do
+        hash = @item.serializable_hash(:except => :description)
+        hash['title'].should_not be_nil
+        hash['description'].should be_nil
+      end
+
+      it "should add :methods with :only option" do
+        @item.serializable_hash(:only => :title, :methods => :a_method).should == {
+          'title' => 'Serialization',
+          'a_method' => 1
+        }
+      end
+
+      it "should call #serializable_hash on embedded many docs" do
+        @item.serializable_hash.should == {
+          'id'          => @item.id,
+          'title'       => 'Serialization',
+          'description' => 'Make it work like magic!',
+          'assignments' => [{'user_id' => @user2.id}]
+        }
+      end
+
+      context "with :include" do
+        before do
+          @list = List.new(:title => 'MarkMapper', :items => [@item], :creator => @user1)
+        end
+
+        it "should add many association" do
+          hash = @list.serializable_hash(:include => :items)
+          hash['items'].should be_instance_of(Array)
+          hash['items'].first['title'].should == 'Serialization'
+        end
+
+        it "should add belongs_to association" do
+          hash = @list.serializable_hash(:include => :creator)
+          hash['creator'].should == @user1.serializable_hash
+        end
+
+        it "should add one association" do
+          author_class = Doc do
+            key :post_id, ObjectId
+          end
+          post_class = Doc('Post') do
+            one :author, :class => author_class
+          end
+
+          author = author_class.new
+          hash = post_class.new(:author => author).serializable_hash(:include => :author)
+          hash['author'].should == author.serializable_hash
+        end
+
+        it "should include multiple associations" do
+          hash = @list.serializable_hash(:include => [:items, :creator])
+          hash['items'].should be_instance_of(Array)
+          hash['creator'].should == @user1.serializable_hash
+        end
+
+        it "should include multiple associations with options" do
+          hash = @list.serializable_hash(:include => {:creator => {:only => :name}})
+          hash['creator'].should == @user1.serializable_hash(:only => :name)
+        end
+      end
+    end
+
+    [:json, :xml].each do |format|
+      context format do
+        it "should be reversable" do
+          serialized = @instance.send("to_#{format}")
+          unserialized = @document.send("from_#{format}", serialized)
+
+          @instance.should == unserialized
+        end
+
+        it "should allow attribute only filtering" do
+          serialized = @instance.send("to_#{format}", :only => [ :age, :name ])
+          unserialized = @document.send("from_#{format}", serialized)
+
+          @instance.name.should == unserialized.name
+          @instance.age.should == unserialized.age
+          unserialized.awesome.should be_falsey
+          unserialized.created_at.should be_nil
+        end
+
+        it "should allow attribute except filtering" do
+          serialized = @instance.send("to_#{format}", :except => [ :age, :name ])
+          unserialized = @document.send("from_#{format}", serialized)
+
+          unserialized.name.should be_nil
+          unserialized.age.should be_nil
+          @instance.awesome.should == unserialized.awesome
+        end
+      end
+    end
+  end
+end