mongo_mapper 0.12.0 → 0.13.0.beta1

data/test/unit/associations/test_belongs_to_association.rb

@@ -1,29 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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/serializers/test_json_serializer.rb

@@ -1,216 +0,0 @@
-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

data/test/unit/serializers/test_xml_serializer.rb

@@ -1,196 +0,0 @@
-require 'test_helper'
-
-class XmlSerializationTest < Test::Unit::TestCase
-  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 => 'XmlSerializationTest::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
-    assert_match %r{<top-level-contact>}, @top_level_contact.to_xml
-  end
-
-  should "include demodulized root" do
-    assert_match %r{<contact>}, @contact.to_xml
-  end
-
-  should "encode all encodable attributes" do
-    xml = @contact.to_xml
-
-    assert_no_match %r{_id}, xml
-    assert_match %r{<id>#{@contact.id}</id>}, xml
-    assert_match %r{<name>Konata Izumi</name>}, xml
-    assert_match %r{<age.*>16</age>}, xml
-    assert_match %r(<created-at type="datetime">), xml
-    assert_match %r{<awesome type="boolean">true</awesome>}, xml
-    assert_match %r{<preferences>}, xml
-    assert_match %r{<shows>anime</shows>}, xml
-  end
-
-  should "allow attribute filtering with only" do
-    xml = @contact.to_xml(:only => [:name, :age])
-
-    assert_no_match %r{<id>}, xml
-    assert_match %r{<name>Konata Izumi</name>}, xml
-    assert_match %r{<age type="integer">16</age>}, xml
-    assert_no_match %r{awesome}, xml
-    assert_no_match %r{created-at}, xml
-    assert_no_match %r{preferences}, xml
-  end
-
-  should "allow attribute filtering with except" do
-    xml = @contact.to_xml(:except => [:name, :age])
-
-    assert_no_match %r{<name>Konata Izumi</name>}, xml
-    assert_no_match %r{<age type="integer">16</age>}, xml
-    assert_match %r{<id>}, xml
-    assert_match %r{awesome}, xml
-    assert_match %r{created-at}, xml
-    assert_match %r{preferences}, xml
-  end
-
-  context "_id key" do
-    should "not be included by default" do
-      assert_no_match %r{_id}, @contact.to_xml
-    end
-
-    should "not be included even if :except is used" do
-      assert_no_match %r{_id}, @contact.to_xml(:except => :name)
-    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
-      assert_match %r{<id>#{@contact.id}</id>}, @contact.to_xml
-    end
-
-    should "be included when single method included" do
-      xml = @contact.to_xml(:methods => :label)
-      assert_match %r{<id>}, xml
-      assert_match %r{<label>Has cheezburger</label>}, xml
-      assert_match %r{<name>Konata Izumi</name>}, xml
-      assert_no_match %r{favorite_quote}, xml
-    end
-
-    should "be included when multiple methods included" do
-      xml = @contact.to_xml(:methods => [:label, :favorite_quote])
-      assert_match %r{<id>}, xml
-      assert_match %r{<label>Has cheezburger</label>}, xml
-      assert_match %r{<name>Konata Izumi</name>}, xml
-      assert_match %r{<favorite-quote>Constraints are liberating</favorite-quote>}, xml
-    end
-
-    should "not be included if :only is present" do
-      assert_no_match %r{<id}, @contact.to_xml(:only => :name)
-    end
-
-    should "be represented by a string" do
-      assert_match %r{<id>}, @contact.to_xml
-    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
-      assert_match %r{<label>Has cheezburger</label>}, @contact.to_xml(:methods => :label)
-    end
-
-    should "include multiple methods" do
-      xml = @contact.to_xml(:only => :name, :methods => [:label, :favorite_quote])
-      assert_match %r{<label>Has cheezburger</label>}, xml
-      assert_match %r{<favorite-quote>Constraints are liberating</favorite-quote>}, xml
-      assert_match %r{<name>Konata Izumi</name>}, xml
-      assert_no_match %r{age}, xml
-      assert_no_match %r{awesome}, xml
-      assert_no_match %r{created-at}, xml
-      assert_no_match %r{preferences}, xml
-
-      # Assert only one tag is created
-      xml.scan(/favorite-quote/).size.should == 2
-    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
-      xml = @contacts.to_xml(:only => :name)
-      assert_match %r{<name>David</name>}, xml
-      assert_match %r{<name>Mary</name>},  xml
-    end
-
-    should "allow attribute filtering with except" do
-      xml = @contacts.to_xml(:except => [:name, :preferences, :awesome, :created_at, :updated_at])
-      assert_match %r{<age type="integer">39</age>}, xml
-      assert_match %r{<age type="integer">14</age>}, xml
-      assert_no_match %r{name},        xml
-      assert_no_match %r{preferences}, xml
-      assert_no_match %r{awesome},     xml
-      assert_no_match %r{created-at},  xml
-      assert_no_match %r{updated-at},  xml
-    end
-  end
-
-  should "include embedded attributes" do
-    contact = Contact.new(:name => 'John', :age => 27)
-    contact.tags = [Tag.new(:name => 'awesome'), Tag.new(:name => 'ruby')]
-    xml = contact.to_xml
-    assert_match %r{<tags type="array">}, xml
-    assert_match %r{<id>#{contact.tags[0].id}</id>}, xml
-    assert_match %r{<id>#{contact.tags[1].id}</id>}, xml
-    assert_match %r{<name>awesome</name>}, xml
-    assert_match %r{<name>ruby</name>}, xml
-  end
-
-  should "include dynamic attributes" do
-    contact = Contact.new(:name => 'John', :age => 27, :foo => 'bar')
-    contact['smell'] = 'stinky'
-    assert_match %r{<smell>stinky</smell>}, contact.to_xml
-  end
-end