lookout-mongo_mapper 0.11.3

data/test/unit/associations/test_belongs_to_association.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+require 'models'
+
+class BelongsToAssociationTest < Test::Unit::TestCase
+  include MongoMapper::Plugins::Associations
+
+  context "class_name" do
+    should "camelize the name" do
+      BelongsToAssociation.new(:user).class_name.should == 'User'
+    end
+
+    should "be changeable using class_name option" do
+      association = BelongsToAssociation.new(:user, :class_name => 'Person')
+      association.class_name.should == 'Person'
+    end
+  end
+
+  context "embeddable?" do
+    should "be false even if class is embeddable" do
+      base = BelongsToAssociation.new(:address)
+      base.embeddable?.should be_false
+    end
+
+    should "be false if class is not embeddable" do
+      base = BelongsToAssociation.new(:project)
+      base.embeddable?.should be_false
+    end
+  end
+end

data/test/unit/associations/test_many_association.rb

@@ -0,0 +1,63 @@
+require 'test_helper'
+require 'models'
+
+class ManyAssociationTest < Test::Unit::TestCase
+  include MongoMapper::Plugins::Associations
+
+  context "class_name" do
+    should "camelize the name" do
+      ManyAssociation.new(:smart_people).class_name.should == 'SmartPerson'
+    end
+
+    should "be changeable using class_name option" do
+      base = ManyAssociation.new(:smart_people, :class_name => 'IntelligentPerson')
+      base.class_name.should == 'IntelligentPerson'
+    end
+  end
+
+  context "type_key_name" do
+    should "be _type" do
+      ManyAssociation.new(:foos).type_key_name.should == '_type'
+    end
+  end
+
+  context "embeddable?" do
+    should "be true if class is embeddable" do
+      base = ManyAssociation.new(:medias)
+      base.embeddable?.should be_true
+    end
+
+    should "be false if class is not embeddable" do
+      base = ManyAssociation.new(:statuses)
+      base.embeddable?.should be_false
+    end
+  end
+
+  context "proxy_class" do
+    should "be ManyDocumentsProxy for many" do
+      base = ManyAssociation.new(:statuses)
+      base.proxy_class.should == ManyDocumentsProxy
+    end
+
+    should "be ManyPolymorphicProxy for polymorphic many" do
+      base = ManyAssociation.new(:messages, :polymorphic => true)
+      base.proxy_class.should == ManyPolymorphicProxy
+    end
+
+    should "be ManyEmbeddedProxy for many embedded" do
+      base = ManyAssociation.new(:medias)
+      base.proxy_class.should == ManyEmbeddedProxy
+    end
+
+    should "be ManyEmbeddedPolymorphicProxy for polymorphic many embedded" do
+      base = ManyAssociation.new(:medias, :polymorphic => true)
+      base.proxy_class.should == ManyEmbeddedPolymorphicProxy
+    end
+
+    should "be InArrayProxy for many with :in option" do
+      base = ManyAssociation.new(:messages, :in => :message_ids)
+      base.proxy_class.should == InArrayProxy
+    end
+  end
+
+end

data/test/unit/associations/test_one_association.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+require 'models'
+
+class OneAssociationTest < Test::Unit::TestCase
+  include MongoMapper::Plugins::Associations
+
+  context "type_key_name" do
+    should "be _type" do
+      OneAssociation.new(:foo).type_key_name.should == '_type'
+    end
+  end
+
+  context "embeddable?" do
+    should "be true if class is embeddable" do
+      base = OneAssociation.new(:media)
+      base.embeddable?.should be_true
+    end
+
+    should "be false if class is not embeddable" do
+      base = OneAssociation.new(:project)
+      base.embeddable?.should be_false
+    end
+  end
+
+  context "proxy_class" do
+    should "be OneProxy for one" do
+      base = OneAssociation.new(:status)
+      base.proxy_class.should == OneProxy
+    end
+
+    should "be OneAsProxy for one with :as option" do
+      base = OneAssociation.new(:message, :as => :messagable)
+      base.proxy_class.should == OneAsProxy
+    end
+
+    should "be OneEmbeddedProxy for one embedded" do
+      base = OneAssociation.new(:media)
+      base.proxy_class.should == OneEmbeddedProxy
+    end
+
+    should "be OneEmbeddedPolymorphicProxy for polymorphic one embedded" do
+      base = OneAssociation.new(:media, :polymorphic => true)
+      base.proxy_class.should == OneEmbeddedPolymorphicProxy
+    end
+  end
+
+end

data/test/unit/associations/test_proxy.rb

@@ -0,0 +1,100 @@
+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 "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,216 @@
+require 'test_helper'
+
+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