mongo_mapper 0.12.0 → 0.13.0.beta1

data/test/unit/test_identity_map_middleware.rb

@@ -1,132 +0,0 @@
-require 'test_helper'
-require 'rack/test'
-
-class IdentityMapMiddlewareTest < Test::Unit::TestCase
-  include Rack::Test::Methods
-
-  def app
-    @app ||= Rack::Builder.new do
-      use MongoMapper::Middleware::IdentityMap
-
-      map "/" do
-        run lambda {|env| [200, {}, []] }
-      end
-
-      map "/fail" do
-        run lambda {|env| raise "FAIL!" }
-      end
-    end.to_app
-  end
-
-  context "" do
-    setup do
-      @enabled = MongoMapper::Plugins::IdentityMap.enabled
-      MongoMapper::Plugins::IdentityMap.enabled = false
-    end
-
-    teardown do
-      MongoMapper::Plugins::IdentityMap.enabled = @enabled
-    end
-
-    should "delegate" do
-      called = false
-      mw = MongoMapper::Middleware::IdentityMap.new lambda { |env|
-        called = true
-        [200, {}, nil]
-      }
-      mw.call({})
-      called.should be_true
-    end
-
-    should "enable identity map during delegation" do
-      mw = MongoMapper::Middleware::IdentityMap.new lambda { |env|
-        MongoMapper::Plugins::IdentityMap.should be_enabled
-        [200, {}, nil]
-      }
-      mw.call({})
-    end
-
-    class Enum < Struct.new(:iter)
-      def each(&b)
-        iter.call(&b)
-      end
-    end
-
-    should "enable IM for body each" do
-      mw = MongoMapper::Middleware::IdentityMap.new lambda { |env|
-        [200, {}, Enum.new(lambda { |&b|
-          MongoMapper::Plugins::IdentityMap.should be_enabled
-          b.call "hello"
-        })]
-      }
-      body = mw.call({}).last
-      body.each { |x| x.should eql('hello') }
-    end
-
-    should "disable IM after body close" do
-      mw = MongoMapper::Middleware::IdentityMap.new lambda { |env| [200, {}, []] }
-      body = mw.call({}).last
-      MongoMapper::Plugins::IdentityMap.should be_enabled
-      body.close
-      MongoMapper::Plugins::IdentityMap.should_not be_enabled
-    end
-
-    should "clear IM after body close" do
-      mw = MongoMapper::Middleware::IdentityMap.new lambda { |env| [200, {}, []] }
-      body = mw.call({}).last
-
-      MongoMapper::Plugins::IdentityMap.repository['hello'] = 'world'
-      MongoMapper::Plugins::IdentityMap.repository.should_not be_empty
-
-      body.close
-
-      MongoMapper::Plugins::IdentityMap.repository.should be_empty
-    end
-
-    context "with a successful request" do
-      should "clear the identity map" do
-        MongoMapper::Plugins::IdentityMap.expects(:clear).twice
-        get '/'
-      end
-    end
-
-    context "when the request raises an error" do
-      should "clear the identity map" do
-        MongoMapper::Plugins::IdentityMap.expects(:clear).once
-        get '/fail' rescue nil
-      end
-    end
-  end
-end
-
-# class IdentityMapMiddlewareTest < Test::Unit::TestCase
-#   include Rack::Test::Methods
-
-#   def app
-#     @app ||= Rack::Builder.new do
-#       use MongoMapper::Middleware::IdentityMap
-#       map "/" do
-#         run lambda {|env| [200, {}, []] }
-#       end
-#       map "/fail" do
-#         run lambda {|env| raise "FAIL!" }
-#       end
-#     end.to_app
-#   end
-
-#   context "with a successful request" do
-#     should "clear the identity map" do
-#       MongoMapper::Plugins::IdentityMap.expects(:clear).twice
-#       get '/'
-#     end
-#   end
-
-#   context "when the request raises an error" do
-#     should "clear the identity map" do
-#       MongoMapper::Plugins::IdentityMap.expects(:clear).twice
-#       get '/fail' rescue nil
-#     end
-#   end
-
-
-# end

data/test/unit/test_keys.rb

@@ -1,65 +0,0 @@
-require 'test_helper'
-require 'models'
-
-class KeyTest < Test::Unit::TestCase
-  context ".new with no id and _id of type integer" do
-    should "not error" do
-      lambda {
-        klass = Doc() do
-          key :_id, Integer
-        end
-        # No sensible default id for integer, people better pass them in if they user this
-        silence_stderr { klass.new.id.should be_nil }
-      }.should_not raise_error
-    end
-  end
-
-  context ".key?(:symbol)" do
-    should "be true if document has key" do
-      Address.key?(:city).should be_true
-    end
-
-    should "be false if document does not have key" do
-      Address.key?(:foo).should be_false
-    end
-  end
-
-  context ".key?('string')" do
-    should "be true if document has key" do
-      Address.key?('city').should be_true
-    end
-
-    should "be false if document does not have key" do
-      Address.key?('foo').should be_false
-    end
-  end
-
-  context ".new (from database)" do
-    setup do
-      @klass = Doc do
-        key :user, Hash
-
-        def user=(user)
-          super(:id => user.id, :name => user.name)
-        end
-      end
-
-      user_class = Struct.new(:id, :name)
-      @klass.create(:user => user_class.new(1, 'John Nunemaker'))
-    end
-
-    should "use []= for keys instead of public writer" do
-      assert_nothing_raised do
-        doc = @klass.first
-        doc.user['id'].should   == 1
-        doc.user['name'].should == 'John Nunemaker'
-      end
-    end
-  end
-
-  context ".load" do
-    should "return nil if argument is nil" do
-      Doc().load(nil).should be_nil
-    end
-  end
-end # KeyTest

data/test/unit/test_mongo_mapper.rb

@@ -1,157 +0,0 @@
-require 'test_helper'
-
-class Address; end
-
-class MongoMapperTest < Test::Unit::TestCase
-  should "be able to write and read connection" do
-    conn = Mongo::Connection.new
-    MongoMapper.connection = conn
-    MongoMapper.connection.should == conn
-  end
-
-  should "default connection to new mongo ruby driver" do
-    MongoMapper.connection = nil
-    MongoMapper.connection.should be_instance_of(Mongo::Connection)
-  end
-
-  should "be able to write and read default database" do
-    MongoMapper.database = 'test'
-    MongoMapper.database.should be_instance_of(Mongo::DB)
-    MongoMapper.database.name.should == 'test'
-  end
-
-  should "have document not found error" do
-    lambda {
-      MongoMapper::DocumentNotFound
-    }.should_not raise_error
-  end
-
-  should "be able to read/write config" do
-    config = {
-      'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test'},
-      'production'  => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test-prod'}
-    }
-    MongoMapper.config = config
-    MongoMapper.config.should == config
-  end
-
-  context "connecting to environment from config" do
-    should "work without authentication" do
-      MongoMapper.config = {
-        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test'}
-      }
-      Mongo::Connection.expects(:new).with('127.0.0.1', 27017, {})
-      MongoMapper.expects(:database=).with('test')
-      Mongo::DB.any_instance.expects(:authenticate).never
-      MongoMapper.connect('development')
-    end
-
-    should "work without authentication using uri" do
-      MongoMapper.config = {
-        'development' => {'uri' => 'mongodb://127.0.0.1:27017/test'}
-      }
-      Mongo::Connection.expects(:new).with('127.0.0.1', 27017, {})
-      MongoMapper.expects(:database=).with('test')
-      Mongo::DB.any_instance.expects(:authenticate).never
-      MongoMapper.connect('development')
-    end
-
-    should "work with sinatra environment symbol" do
-      MongoMapper.config = {
-        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test'}
-      }
-      Mongo::Connection.expects(:new).with('127.0.0.1', 27017, {})
-      MongoMapper.expects(:database=).with('test')
-      Mongo::DB.any_instance.expects(:authenticate).never
-      MongoMapper.connect(:development)
-    end
-
-    should "work with options" do
-      MongoMapper.config = {
-        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test'}
-      }
-      connection, logger = mock('connection'), mock('logger')
-      Mongo::Connection.expects(:new).with('127.0.0.1', 27017, :logger => logger)
-      MongoMapper.connect('development', :logger => logger)
-    end
-
-    should "work with options from config" do
-      MongoMapper.config = {
-        'development' => {'host' => '192.168.1.1', 'port' => 2222, 'database' => 'test', 'options' => {'safe' => true}}
-      }
-      connection, logger = mock('connection'), mock('logger')
-      Mongo::Connection.expects(:new).with('192.168.1.1', 2222, :logger => logger, :safe => true)
-      MongoMapper.connect('development', :logger => logger)
-    end
-
-    should "work with options using uri" do
-      MongoMapper.config = {
-        'development' => {'uri' => 'mongodb://127.0.0.1:27017/test'}
-      }
-      connection, logger = mock('connection'), mock('logger')
-      Mongo::Connection.expects(:new).with('127.0.0.1', 27017, :logger => logger)
-      MongoMapper.connect('development', :logger => logger)
-    end
-
-    should "work with authentication" do
-      MongoMapper.config = {
-        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test', 'username' => 'john', 'password' => 'secret'}
-      }
-      Mongo::DB.any_instance.expects(:authenticate).with('john', 'secret')
-      MongoMapper.connect('development')
-    end
-
-    should "work with authentication using uri" do
-      MongoMapper.config = {
-        'development' => {'uri' => 'mongodb://john:secret@127.0.0.1:27017/test'}
-      }
-      Mongo::DB.any_instance.expects(:authenticate).with('john', 'secret')
-      MongoMapper.connect('development')
-    end
-
-    should "raise error for invalid scheme" do
-      MongoMapper.config = {
-        'development' => {'uri' => 'mysql://127.0.0.1:5336/foo'}
-      }
-      assert_raises(MongoMapper::InvalidScheme) { MongoMapper.connect('development') }
-    end
-
-    should "create a replica set connection if config contains multiple hosts in the old format" do
-      MongoMapper.config = {
-        'development' => {
-          'hosts' => [ ['127.0.0.1', 27017], ['localhost', 27017] ],
-          'database' => 'test'
-        }
-      }
-
-      Mongo::ReplSetConnection.expects(:new).with( ['127.0.0.1', 27017], ['localhost', 27017], {'read_secondary' => true} )
-      MongoMapper.expects(:database=).with('test')
-      Mongo::DB.any_instance.expects(:authenticate).never
-      MongoMapper.connect('development', 'read_secondary' => true)
-    end
-
-    should "create a replica set connection if config contains multiple hosts in the new format" do
-      MongoMapper.config = {
-        'development' => {
-          'hosts' => ['127.0.0.1:27017', 'localhost:27017'],
-          'database' => 'test'
-        }
-      }
-
-      Mongo::ReplSetConnection.expects(:new).with( ['127.0.0.1:27017', 'localhost:27017'], {'read_secondary' => true} )
-      MongoMapper.expects(:database=).with('test')
-      Mongo::DB.any_instance.expects(:authenticate).never
-      MongoMapper.connect('development', 'read_secondary' => true)
-    end
-  end
-
-  context "setup" do
-    should "work as shortcut for setting config, environment and options" do
-      config, logger = mock('config'), mock('logger')
-      MongoMapper.expects(:config=).with(config)
-      MongoMapper.expects(:connect).with('development', :logger => logger)
-      MongoMapper.expects(:handle_passenger_forking).once
-      MongoMapper.setup(config, 'development', :logger => logger)
-    end
-  end
-end

data/test/unit/test_pagination.rb

@@ -1,11 +0,0 @@
-require 'test_helper'
-
-class PaginationTest < Test::Unit::TestCase
-  should "default per_page to 25" do
-    Doc().per_page.should == 25
-  end
-
-  should "allow overriding per_page" do
-    Doc() { def self.per_page; 1 end }.per_page.should == 1
-  end
-end

data/test/unit/test_rails_compatibility.rb

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-class TestRailsCompatibility < Test::Unit::TestCase
-  class Item
-    include MongoMapper::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
-
-  context "EmbeddedDocument" do
-    should "alias many to has_many" do
-      FirstItem.should respond_to(:has_many)
-    end
-
-    should "alias one to has_one" do
-      FirstItem.should respond_to(:has_one)
-    end
-
-    should "have column names" do
-      Item.column_names.sort.should == ['_id', '_type', 'for_all']
-      FirstItem.column_names.sort.should == ['_id', '_type', 'first_only', 'for_all']
-      SecondItem.column_names.sort.should == ['_id', '_type', 'for_all', 'second_only']
-    end
-
-    should "alias new to new_record?" do
-      instance = Item.new
-      instance.new_record?.should == instance.new?
-    end
-  end
-end

data/test/unit/test_serialization.rb

@@ -1,166 +0,0 @@
-require 'test_helper'
-
-class SerializationTest < Test::Unit::TestCase
-  def setup
-    @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
-    class List
-      include MongoMapper::Document
-      key :name
-      many :items,          :class_name => 'SerializationTest::Item'
-      belongs_to :creator,  :class_name => 'SerializationTest::User'
-    end
-
-    class Item
-      include MongoMapper::Document
-
-      key :title
-      key :description
-      many :assignments, :class_name => 'SerializationTest::Assignment'
-
-      def a_method
-        1
-      end
-    end
-
-    class Assignment
-      include MongoMapper::EmbeddedDocument
-      belongs_to :assigned_by,  :class_name => 'SerializationTest::User'
-      belongs_to :user,         :class_name => 'SerializationTest::User'
-
-      def serializable_hash(options = {})
-        super({:only => :user_id}.merge(options))
-      end
-    end
-
-    class User
-      include MongoMapper::Document
-      key :name, String
-    end
-
-    setup 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
-
-    should "only include specified attributes with :only option" do
-      @item.serializable_hash(:only => :title).should == {'title' => 'Serialization'}
-    end
-
-    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
-
-    should "add :methods with :only option" do
-      @item.serializable_hash(:only => :title, :methods => :a_method).should == {
-        'title' => 'Serialization',
-        'a_method' => 1
-      }
-    end
-
-    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
-      setup do
-        @list = List.new(:title => 'MongoMapper', :items => [@item], :creator => @user1)
-      end
-
-      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
-
-      should "add belongs_to association" do
-        hash = @list.serializable_hash(:include => :creator)
-        hash['creator'].should == @user1.serializable_hash
-      end
-
-      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
-
-      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
-
-      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
-      should "be reversable" do
-        serialized = @instance.send("to_#{format}")
-        unserialized = @document.send("from_#{format}", serialized)
-
-        assert_equal @instance, unserialized
-      end
-
-      should "allow attribute only filtering" do
-        serialized = @instance.send("to_#{format}", :only => [ :age, :name ])
-        unserialized = @document.send("from_#{format}", serialized)
-
-        assert_equal @instance.name, unserialized.name
-        assert_equal @instance.age, unserialized.age
-        assert ! unserialized.awesome
-        assert_nil unserialized.created_at
-      end
-
-      should "allow attribute except filtering" do
-        serialized = @instance.send("to_#{format}", :except => [ :age, :name ])
-        unserialized = @document.send("from_#{format}", serialized)
-
-        assert_nil unserialized.name
-        assert_nil unserialized.age
-        assert_equal @instance.awesome, unserialized.awesome
-      end
-    end
-  end
-end