honkster-mongo_mapper 0.8.4

data/test/unit/associations/test_proxy.rb

@@ -0,0 +1,105 @@
+require 'test_helper'
+
+class FakeNilProxy < MongoMapper::Plugins::Associations::Proxy
+  def find_target; nil end
+end
+
+class FakeBlankProxy < MongoMapper::Plugins::Associations::Proxy
+  def find_target; '' end
+end
+
+class FakeNumberProxy < MongoMapper::Plugins::Associations::Proxy
+  def find_target; 17 end
+end
+
+class FakeProxy < MongoMapper::Plugins::Associations::Proxy
+  def find_target; [1, 2] end
+end
+
+class ProxyTest < Test::Unit::TestCase
+  def setup
+    @owner = mock('owner')
+    @owner.stubs(:new?).returns(false)
+    @association = mock('association')
+    @association.stubs(:options).returns({:extend => []})
+
+    @proxy       = FakeProxy.new(@owner, @association)
+    @nil_proxy   = FakeNilProxy.new(@owner, @association)
+    @blank_proxy = FakeBlankProxy.new(@owner, @association)
+  end
+
+  should 'return true for === target' do
+    @proxy = FakeProxy.new(@owner, @association)
+    @proxy.should === Array
+  end
+
+  should "set target to nil when reset is called" do
+    @proxy.reset
+    @proxy.target.should be_nil
+  end
+
+  should "be able to inspect the proxy" do
+    @proxy.inspect.should == '[1, 2]'
+  end
+
+  context "nil?" do
+    should "be true if nil" do
+      @nil_proxy.nil?.should be_true
+    end
+
+    should "be false if not nil" do
+      @proxy.nil?.should be_false
+    end
+  end
+
+  context "blank?" do
+    should "be true if blank" do
+      @blank_proxy.blank?.should be_true
+      @nil_proxy.blank?.should be_true
+    end
+
+    should "be false if not blank" do
+      @proxy.blank?.should be_false
+    end
+  end
+
+  context "present?" do
+    should "be true if present" do
+      @proxy.present?.should be_true
+    end
+
+    should "be false if not present" do
+      @blank_proxy.present?.should be_false
+      @nil_proxy.present?.should be_false
+    end
+  end
+
+  should "delegate respond_to? to target" do
+    @proxy.respond_to?(:each).should be_true
+    @proxy.respond_to?(:size).should be_true
+    @proxy.respond_to?(:gsub).should be_false
+  end
+
+  should "alias proxy owner to owner" do
+    @proxy.proxy_owner.should == @owner
+  end
+
+  should "alias proxy target to target" do
+    @proxy.proxy_target.should == @target
+  end
+
+  context "send" do
+    should "work if proxy responds to method" do
+      @proxy.send(:reset)
+      @proxy.target.should be_nil
+    end
+
+    should "work if the target responds to the method" do
+      @proxy.send(:size).should == 2
+    end
+
+    should "not work if neither the proxy or target respond to method" do
+      lambda { @proxy.send(:gsub) }.should raise_error
+    end
+  end
+end

data/test/unit/serializers/test_json_serializer.rb

@@ -0,0 +1,217 @@
+require 'test_helper'
+require 'active_support/version'
+
+class JsonSerializationTest < Test::Unit::TestCase
+
+  # Helper function in case things change in the future
+  # - replacing all those to_json calls was a nightmare
+  def convert_to_json(object, options={})
+    ActiveSupport::JSON.encode(object, options)
+  end
+
+  class Tag
+    include MongoMapper::EmbeddedDocument
+    key :name, String
+  end
+
+  class Contact
+    include MongoMapper::Document
+    key :name, String
+    key :age, Integer
+    key :created_at, Time
+    key :awesome, Boolean
+    key :preferences, Hash
+
+    many :tags, :class_name => 'JsonSerializationTest::Tag'
+  end
+
+  def setup
+    Kernel.const_set('TopLevelContact', Doc('TopLevelContact'))
+    TopLevelContact.key :name, String
+
+    Contact.include_root_in_json = false
+    @contact = Contact.new(
+      :name        => 'Konata Izumi',
+      :age         => 16,
+      :created_at  => Time.utc(2006, 8, 1),
+      :awesome     => true,
+      :preferences => { :shows => 'anime' }
+    )
+    @top_level_contact = TopLevelContact.new(
+      :name        => 'Konata Izumi'
+    )
+  end
+
+  def teardown
+    Kernel.send(:remove_const, 'TopLevelContact') if Object.const_defined?('TopLevelContact')
+  end
+
+  should "include root for class with no module" do
+    TopLevelContact.include_root_in_json = true
+    assert_match %r{^\{"top_level_contact":\s?\{}, convert_to_json(@top_level_contact)
+  end
+
+  should "include demodulized root" do
+    Contact.include_root_in_json = true
+    assert_match %r{^\{"contact":\s?\{}, convert_to_json(@contact)
+  end
+
+  should "encode all encodable attributes" do
+    json = convert_to_json(@contact)
+
+    assert_no_match %r{"_id"}, json
+    assert_match %r{"name":"Konata Izumi"}, json
+    assert_match %r{"age":16}, json
+    assert json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_match %r{"awesome":true}, json
+    assert_match %r{"preferences":\{"shows":"anime"\}}, json
+  end
+
+  should "allow attribute filtering with only" do
+    json = convert_to_json(@contact, :only => [:name, :age])
+
+    assert_no_match %r{"_id"}, json
+    assert_match %r{"name":"Konata Izumi"}, json
+    assert_match %r{"age":16}, json
+    assert_no_match %r{"awesome"}, json
+    assert_no_match %r{"created_at"}, json
+    assert_no_match %r{"preferences"}, json
+  end
+
+  should "allow attribute filtering with except" do
+    json = convert_to_json(@contact, :except => [:name, :age])
+
+    assert_no_match %r{"_id"}, json
+    assert_no_match %r{"name"}, json
+    assert_no_match %r{"age"}, json
+    assert_match %r{"awesome"}, json
+    assert_match %r{"created_at"}, json
+    assert_match %r{"preferences"}, json
+  end
+
+  context "_id key" do
+    should "not be included by default" do
+      json = convert_to_json(@contact)
+      assert_no_match %r{"_id":}, json
+    end
+
+    should "not be included even if :except is used" do
+      json = convert_to_json(@contact, :except => :name)
+      assert_no_match %r{"_id":}, json
+    end
+  end
+
+  context "id method" do
+    setup do
+      def @contact.label; "Has cheezburger"; end
+      def @contact.favorite_quote; "Constraints are liberating"; end
+    end
+
+    should "be included by default" do
+      json = convert_to_json(@contact)
+      assert_match %r{"id"}, json
+    end
+
+    should "be included when single method included" do
+      json = convert_to_json(@contact, :methods => :label)
+      assert_match %r{"id"}, json
+      assert_match %r{"label":"Has cheezburger"}, json
+      assert_match %r{"name":"Konata Izumi"}, json
+      assert_no_match %r{"favorite_quote":"Constraints are liberating"}, json
+    end
+
+    should "be included when multiple methods included" do
+      json = convert_to_json(@contact, :methods => [:label, :favorite_quote])
+      assert_match %r{"id"}, json
+      assert_match %r{"label":"Has cheezburger"}, json
+      assert_match %r{"favorite_quote":"Constraints are liberating"}, json
+      assert_match %r{"name":"Konata Izumi"}, json
+    end
+
+    should "not be included if :only is present" do
+      json = convert_to_json(@contact, :only => :name)
+      assert_no_match %r{"id":}, json
+    end
+
+    should "be represented by a string" do
+      json = convert_to_json(@contact)
+      assert_match %r{"id":"}, json
+    end
+  end
+
+  context "including methods" do
+    setup do
+      def @contact.label; "Has cheezburger"; end
+      def @contact.favorite_quote; "Constraints are liberating"; end
+    end
+
+    should "include single method" do
+      json = convert_to_json(@contact, :methods => :label)
+      assert_match %r{"label":"Has cheezburger"}, json
+    end
+
+    should "include multiple methods" do
+      json = convert_to_json(@contact, :only => :name, :methods => [:label, :favorite_quote])
+      assert_match %r{"label":"Has cheezburger"}, json
+      assert_match %r{"favorite_quote":"Constraints are liberating"}, json
+      assert_match %r{"name":"Konata Izumi"}, json
+      assert_no_match %r{"age":16}, json
+      assert_no_match %r{"awesome"}, json
+      assert_no_match %r{"created_at"}, json
+      assert_no_match %r{"preferences"}, json
+    end
+  end
+
+  context "array of records" do
+    setup do
+      @contacts = [
+        Contact.new(:name => 'David', :age => 39),
+        Contact.new(:name => 'Mary', :age => 14)
+      ]
+    end
+
+    should "allow attribute filtering with only" do
+      json =convert_to_json(@contacts, :only => :name)
+      assert_match %r{\{"name":"David"\}}, json
+      assert_match %r{\{"name":"Mary"\}}, json
+    end
+
+    should "allow attribute filtering with except" do
+      json = convert_to_json(@contacts, :except => [:name, :preferences, :awesome, :created_at, :updated_at])
+      assert_match %r{"age":39},          json
+      assert_match %r{"age":14},          json
+      assert_no_match %r{"name":},        json
+      assert_no_match %r{"preferences":}, json
+      assert_no_match %r{"awesome":},     json
+      assert_no_match %r{"created_at":},  json
+      assert_no_match %r{"updated_at":},  json
+    end
+  end
+
+  should "allow options for hash of records" do
+    contacts = {
+      1 => Contact.new(:name => 'David', :age => 39),
+      2 => Contact.new(:name => 'Mary', :age => 14)
+    }
+    json = convert_to_json(contacts, :only => [1, :name])
+    assert_match %r{"1":},               json
+    assert_match %r{\{"name":"David"\}}, json
+    assert_no_match %r{"2":},            json
+  end
+
+  should "include embedded attributes" do
+    contact = Contact.new(:name => 'John', :age => 27)
+    contact.tags = [Tag.new(:name => 'awesome'), Tag.new(:name => 'ruby')]
+    json = convert_to_json(contact)
+    assert_match %r{"tags":}, json
+    assert_match %r{"name":"awesome"}, json
+    assert_match %r{"name":"ruby"}, json
+  end
+
+  should "include dynamic attributes" do
+    contact = Contact.new(:name => 'John', :age => 27, :foo => 'bar')
+    contact['smell'] = 'stinky'
+    json = convert_to_json(contact)
+    assert_match %r{"smell":"stinky"}, json
+  end
+end

data/test/unit/test_clone.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+class CloneTest < Test::Unit::TestCase
+  context "Document" do
+    setup 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
+      should "be new" do
+        @doc.clone.should be_new
+      end
+
+      should "copy the attributes" do
+        clone = @doc.clone
+        clone.name.should == "foo"
+        clone.age.should == 27
+      end
+
+      should "clone duplicable attributes" do
+        @doc.clone.tags.should_not equal(@tags)
+      end
+
+      should "clone many embedded documents" do
+        @doc.clone.widgets.object_id.should_not equal(@doc.widgets.object_id)
+      end
+
+      should "not be destroyed" do
+        @doc.destroy
+        @doc.clone.should_not be_destroyed
+      end
+    end
+  end
+
+  context "EmbeddedDocument" do
+    setup do
+      @document = EDoc do
+        key :name, String
+        key :age, Integer
+      end
+    end
+
+    context "#clone" do
+      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
+
+      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/test/unit/test_descendant_appends.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+class DescendantAppendsTest < Test::Unit::TestCase
+  context "Document" do
+    should "default descendants to a new set" do
+      MongoMapper::Document.descendants.should be_instance_of(Set)
+    end
+
+    should 'allow extensions to Document to be appended' do
+      module Extension; def test_this_extension; end end
+      MongoMapper::Document.append_extensions(Extension)
+      article = Doc()
+      article.should respond_to(:test_this_extension)
+    end
+
+    should 'add appended extensions to classes that include Document before they are added' do
+      module Extension; def test_this_extension; end end
+      article = Doc()
+      MongoMapper::Document.append_extensions(Extension)
+      article.should respond_to(:test_this_extension)
+    end
+
+    should 'allow inclusions to Document to be appended' do
+      module Inclusion; def test_this_inclusion; end end
+      MongoMapper::Document.append_inclusions(Inclusion)
+      article = Doc()
+      article.new.should respond_to(:test_this_inclusion)
+    end
+
+    should 'add appended inclusions to classes that include Document before they are added' do
+      module Inclusion; def test_this_inclusion; end end
+      article = Doc()
+      MongoMapper::Document.append_inclusions(Inclusion)
+      article.new.should respond_to(:test_this_inclusion)
+    end
+  end
+
+  context "EmbeddedDocument" do
+    should "default descendants to a new set" do
+      MongoMapper::EmbeddedDocument.descendants.should be_instance_of(Set)
+    end
+
+    should 'allow extensions to Document to be appended' do
+      module Extension; def test_this_extension; end end
+      MongoMapper::EmbeddedDocument.append_extensions(Extension)
+      article = EDoc()
+      article.should respond_to(:test_this_extension)
+    end
+
+    should 'add appended extensions to classes that include Document before they are added' do
+      module Extension; def test_this_extension; end end
+      article = EDoc()
+      MongoMapper::EmbeddedDocument.append_extensions(Extension)
+      article.should respond_to(:test_this_extension)
+    end
+
+    should 'allow inclusions to Document to be appended' do
+      module Inclusion; def test_this_inclusion; end end
+      MongoMapper::EmbeddedDocument.append_inclusions(Inclusion)
+      article = EDoc()
+      article.new.should respond_to(:test_this_inclusion)
+    end
+
+    should 'add appended inclusions to classes that include Document before they are added' do
+      module Inclusion; def test_this_inclusion; end end
+      article = EDoc()
+      MongoMapper::EmbeddedDocument.append_inclusions(Inclusion)
+      article.new.should respond_to(:test_this_inclusion)
+    end
+  end
+end