mongo_mapper 0.14.0 → 0.15.0

data/spec/unit/associations/proxy_spec.rb

@@ -92,7 +92,7 @@ describe "Proxy" do
     end
 
     it "should not work if neither the proxy or target respond to method" do
-      lambda { @proxy.send(:gsub) }.should raise_error
+      lambda { @proxy.send(:gsub) }.should raise_error(NoMethodError)
     end
 
     it "should work if a proc is passed" do

data/spec/unit/clone_spec.rb

@@ -45,7 +45,7 @@ describe "Clone" do
       end
 
       it "should clone a cloned document" do
-        expect { @doc.clone.clone }.to_not raise_error
+        lambda { @doc.clone.clone }.should_not raise_error
         @doc.clone.clone.id.should be_a BSON::ObjectId
       end
     end

data/spec/unit/document_spec.rb

@@ -21,11 +21,11 @@ describe "Document" do
     end
 
     it "should have a connection" do
-      @document.connection.should be_instance_of(Mongo::MongoClient)
+      @document.connection.should be_instance_of(Mongo::Client)
     end
 
     it "should allow setting different connection without affecting the default" do
-      conn = Mongo::MongoClient.new
+      conn = Mongo::Client.new(['127.0.0.1:27001'])
       @document.connection conn
       @document.connection.should == conn
       @document.connection.should_not == MongoMapper.connection
@@ -152,7 +152,7 @@ describe "Document" do
 
       it "should be true if id but using custom id and not saved yet" do
         @document.key :_id, String
-        doc = silence_stderr { @document.new }
+        doc = suppress_stderr { @document.new }
         doc.id = '1234'
         doc.new?.should be_truthy
       end

data/spec/unit/embedded_document_spec.rb

@@ -210,7 +210,7 @@ describe "EmbeddedDocument" do
         end
 
         it "should not include descendant keys" do
-          lambda { Parent.new.other_child }.should raise_error
+          lambda { Parent.new.other_child }.should raise_error(NoMethodError)
         end
       end
 
@@ -308,7 +308,7 @@ describe "EmbeddedDocument" do
         end
 
         it "should not throw error if initialized with nil" do
-          expect { @document.new(nil) }.to_not raise_error
+          lambda { @document.new(nil) }.should_not raise_error
         end
       end
 
@@ -661,16 +661,15 @@ describe "EmbeddedDocument" do
 
          it "should should raise errors when invalid" do
            @doc.name = ''
-           expect { @doc.save! }.to raise_error(MongoMapper::DocumentNotValid)
+           lambda { @doc.save! }.should raise_error(MongoMapper::DocumentNotValid)
          end
 
          it "should should raise errors when root document is invalid" do
            @root.name = ''
            @root.save(:validate => false)
-           expect{ @doc.save! }.to raise_error(MongoMapper::DocumentNotValid)
+           lambda { @doc.save! }.should raise_error(MongoMapper::DocumentNotValid)
          end
        end
     end # instance of a embedded document
   end
 end
-

data/spec/unit/extensions_spec.rb

@@ -207,7 +207,7 @@ describe "Support" do
   context "ObjectId#to_mongo" do
     it "should call class to_mongo with self" do
       object = Object.new
-      expect(object.class).to receive(:to_mongo).with(object)
+      object.class.should_receive(:to_mongo).with(object)
       object.to_mongo
     end
   end
@@ -300,8 +300,7 @@ describe "Support" do
     end
 
     it "should be time in utc if time" do
-      utc_str = RUBY_PLATFORM != "java" ? 'UTC' : "GMT"
-      Time.to_mongo(Time.local(2009, 8, 15, 0, 0, 0)).zone.should == utc_str
+      Time.to_mongo(Time.local(2009, 8, 15, 0, 0, 0)).zone.should == 'UTC'
     end
 
     it "should be nil if blank string" do
@@ -388,7 +387,7 @@ describe "Support" do
 
       it "should support ruby driver syntax also" do
         id = BSON::ObjectId.new
-        id.original_to_json.should == %Q({"$oid": "#{id}"})
+        id.original_to_json.should == %Q({"$oid":"#{id}"})
       end
     end
   end

data/spec/unit/identity_map_middleware_spec.rb

@@ -19,116 +19,85 @@ module IdentityMapSpec
       end.to_app
     end
 
-    context "" do
-      before do
-        @enabled = MongoMapper::Plugins::IdentityMap.enabled
-        MongoMapper::Plugins::IdentityMap.enabled = false
-      end
+    before do
+      @enabled = MongoMapper::Plugins::IdentityMap.enabled
+      MongoMapper::Plugins::IdentityMap.enabled = false
+    end
 
-      after do
-        MongoMapper::Plugins::IdentityMap.enabled = @enabled
-      end
+    after do
+      MongoMapper::Plugins::IdentityMap.enabled = @enabled
+    end
 
-      it "should delegate" do
-        called = false
-        mw = MongoMapper::Middleware::IdentityMap.new lambda { |env|
-          called = true
-          [200, {}, nil]
-        }
-        mw.call({})
-        called.should be_truthy
-      end
+    it "should delegate" do
+      called = false
+      mw = MongoMapper::Middleware::IdentityMap.new lambda { |env|
+        called = true
+        [200, {}, nil]
+      }
+      mw.call({})
+      called.should be_truthy
+    end
 
-      it "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
+    it "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
+    class Enum < Struct.new(:iter)
+      def each(&b)
+        iter.call(&b)
       end
+    end
 
-      it "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
+    it "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
 
-      it "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
+    it "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
 
-      it "should clear IM after body close" do
-        mw = MongoMapper::Middleware::IdentityMap.new lambda { |env| [200, {}, []] }
-        body = mw.call({}).last
+    it "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
+      MongoMapper::Plugins::IdentityMap.repository['hello'] = 'world'
+      MongoMapper::Plugins::IdentityMap.repository.should_not be_empty
 
-        body.close
+      body.close
 
-        MongoMapper::Plugins::IdentityMap.repository.should be_empty
-      end
+      MongoMapper::Plugins::IdentityMap.repository.should be_empty
+    end
 
-      context "with a successful request" do
-        it "should clear the identity map" do
-          expect(MongoMapper::Plugins::IdentityMap).to receive(:clear).twice
-          get '/'
-        end
+    context "with a successful request" do
+      it "should clear the identity map" do
+        # for some reason, body.close gets called twice - once in rack-2.2.3/lib/rack/response.rb:281
+        # the other time rack-test-0.8.3/lib/rack/mock_session.rb:32
+        # use at_least(:twice) here to handle the error happening more than twice
+        MongoMapper::Plugins::IdentityMap.should_receive(:clear).at_least(:twice)
+        get '/'
       end
+    end
 
-      context "when the request raises an error" do
-        it "should clear the identity map" do
-          expect(MongoMapper::Plugins::IdentityMap).to receive(:clear).once
-          get '/fail' rescue nil
-        end
+    context "when the request raises an error" do
+      it "should clear the identity map" do
+        MongoMapper::Plugins::IdentityMap.should_receive(:clear).once
+        get '/fail' rescue nil
       end
     end
   end
-
-  # describe "IdentityMapMiddleware" do
-  #   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
-  #     it "should clear the identity map" do
-  #       expect(MongoMapper::Plugins::IdentityMap).to receive(:clear).twice
-  #       get '/'
-  #     end
-  #   end
-
-  #   context "when the request raises an error" do
-  #     it "should clear the identity map" do
-  #       expect(MongoMapper::Plugins::IdentityMap).to receive(:clear).twice
-  #       get '/fail' rescue nil
-  #     end
-  #   end
-
-
-  # end
-end
+end

data/spec/unit/key_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 
-
 class FooType < Struct.new(:bar)
   def self.to_mongo(value)
     'to_mongo'
@@ -60,19 +59,19 @@ describe "Key" do
     end
 
     it "should not permit reserved names" do
-      expect { Key.new(:id) }.to raise_error(/reserved/)
+      lambda { Key.new(:id) }.should raise_error(/reserved/)
     end
 
     it "should not permit bad names" do
-      expect { Key.new(:"id.bar") }.to raise_error(/must match/)
+      lambda { Key.new(:"id.bar") }.should raise_error(/must match/)
     end
 
     it "should permit bad names if __dynamic" do
-      expect { Key.new(:"id.bar", :__dynamic => true) }.to_not raise_error
+      lambda { Key.new(:"id.bar", :__dynamic => true) }.should_not raise_error
     end
 
     it "should permit bad names if it is not to create accessors" do
-      expect { Key.new(:"id.bar", :accessors => :skip) }.to_not raise_error
+      lambda { Key.new(:"id.bar", :accessors => :skip) }.should_not raise_error
     end
   end
 
@@ -149,33 +148,33 @@ describe "Key" do
     context "with :read" do
       let(:accessor) { :read }
 
-      it { expect( subject.read_accessor? ).to be_truthy }
-      it { expect( subject.write_accessor? ).to be_falsey }
-      it { expect( subject.predicate_accessor? ).to be_falsey }
+      it { subject.read_accessor?.should be_truthy }
+      it { subject.write_accessor?.should be_falsey }
+      it { subject.predicate_accessor?.should be_falsey }
     end
 
     context "with :write" do
       let(:accessor) { :write }
 
-      it { expect( subject.read_accessor? ).to be_falsey }
-      it { expect( subject.write_accessor? ).to be_truthy }
-      it { expect( subject.predicate_accessor? ).to be_falsey }
+      it { subject.read_accessor?.should be_falsey }
+      it { subject.write_accessor?.should be_truthy }
+      it { subject.predicate_accessor?.should be_falsey }
     end
 
     context "with :predicate" do
       let(:accessor) { :predicate }
 
-      it { expect( subject.read_accessor? ).to be_falsey }
-      it { expect( subject.write_accessor? ).to be_falsey }
-      it { expect( subject.predicate_accessor? ).to be_truthy }
+      it { subject.read_accessor?.should be_falsey }
+      it { subject.write_accessor?.should be_falsey }
+      it { subject.predicate_accessor?.should be_truthy }
     end
 
     context "with an array of options" do
       let(:accessor) { [:read, :write] }
 
-      it { expect( subject.read_accessor? ).to be_truthy }
-      it { expect( subject.write_accessor? ).to be_truthy }
-      it { expect( subject.predicate_accessor? ).to be_falsey }
+      it { subject.read_accessor?.should be_truthy }
+      it { subject.write_accessor?.should be_truthy }
+      it { subject.predicate_accessor?.should be_falsey }
     end
   end
 

data/spec/unit/keys_spec.rb

@@ -9,7 +9,7 @@ describe "Key" 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 }
+        suppress_stderr { klass.new.id.should be_nil }
       }.should_not raise_error
     end
   end
@@ -30,7 +30,7 @@ describe "Key" do
         key :_id, Integer
       end
       doc = klass.new
-      expect(doc).to receive(:warn).once
+      doc.should_receive(:warn).once
       doc.assign({:x => :y})
     end
   end
@@ -82,11 +82,11 @@ describe "Key" do
     end
 
     it "should use []= for keys instead of public writer" do
-      expect {
+      lambda {
         doc = @klass.first
         doc.user['id'].should   == 1
         doc.user['name'].should == 'John Nunemaker'
-      }.to_not raise_error
+      }.should_not raise_error
     end
   end
 
@@ -141,15 +141,15 @@ describe "Key" do
         key :value, Integer, :default => lambda { counter += 1 }
       end
 
-      expect { instance = klass.create }.to change { counter }.by(1)
-      expect {
+      lambda { instance = klass.create }.should change { counter }.by(1)
+      lambda {
         instance.reload.value.should == 1
 
         instance.value = 10
         instance.save
 
         instance.reload.value.should == 10
-      }.to_not change { counter }
+      }.should_not change { counter }
     end
   end
 end # KeyTest

data/spec/unit/mongo_mapper_spec.rb

@@ -3,23 +3,28 @@ require 'spec_helper'
 class Address; end
 
 describe "MongoMapper" do
-  it "should be able to write and read connection" do
-    conn = Mongo::MongoClient.new
+  it "should be able to write and read connection", :without_connection do
+    conn = Mongo::Client.new(['127.0.0.1:27001'])
     MongoMapper.connection = conn
     MongoMapper.connection.should == conn
   end
 
-  it "should default connection to new mongo ruby driver" do
+  it "should default connection to new mongo ruby driver", :without_connection do
     MongoMapper.connection = nil
-    MongoMapper.connection.should be_instance_of(Mongo::MongoClient)
+    MongoMapper.connection.should be_instance_of(Mongo::Client)
   end
 
-  it "should be able to write and read default database" do
-    MongoMapper.database = 'test'
-    MongoMapper.database.should be_instance_of(Mongo::DB)
+  it "should be able to read default database" do
+    MongoMapper.database.should be_instance_of(Mongo::Database)
     MongoMapper.database.name.should == 'test'
   end
 
+  it "should be able to write default database", :without_connection  do
+    MongoMapper.database = 'test-2'
+    MongoMapper.database.should be_instance_of(Mongo::Database)
+    MongoMapper.database.name.should == 'test-2'
+  end
+
   it "should have document not found error" do
     lambda {
       MongoMapper::DocumentNotFound
@@ -35,96 +40,64 @@ describe "MongoMapper" do
     MongoMapper.config.should == config
   end
 
-  context "connecting to environment from config" do
-    it "should work without authentication" do
-      MongoMapper.config = {
-        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test'}
-      }
-      expect(Mongo::MongoClient).to receive(:new).with('127.0.0.1', 27017, {})
-      expect(MongoMapper).to receive(:database=).with('test')
-      expect_any_instance_of(Mongo::DB).to receive(:authenticate).never
-      MongoMapper.connect('development')
-    end
+  context "connecting to environment from config", :without_connection do
 
     it "should work without authentication using uri" do
       MongoMapper.config = {
         'development' => {'uri' => 'mongodb://127.0.0.1:27017/test'}
       }
-      expect(Mongo::MongoClient).to receive(:new).with('127.0.0.1', 27017, {})
-      expect(MongoMapper).to receive(:database=).with('test')
-      expect_any_instance_of(Mongo::DB).to receive(:authenticate).never
+      Mongo::Client.should_receive(:new).with('mongodb://127.0.0.1:27017/test', {})
       MongoMapper.connect('development')
     end
 
-    it "should work with sinatra environment symbol" do
+    it "should work without authentication using hosts" do
       MongoMapper.config = {
-        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test'}
+        'development' => {'hosts' => ['127.0.0.1:27017']}
       }
-      expect(Mongo::MongoClient).to receive(:new).with('127.0.0.1', 27017, {})
-      expect(MongoMapper).to receive(:database=).with('test')
-      expect_any_instance_of(Mongo::DB).to receive(:authenticate).never
-      MongoMapper.connect(:development)
-    end
-
-    it "should work with options" do
-      MongoMapper.config = {
-        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test'}
-      }
-      connection, logger = double('connection'), double('logger')
-      expect(Mongo::MongoClient).to receive(:new).with('127.0.0.1', 27017, :logger => logger)
-      MongoMapper.connect('development', :logger => logger)
-    end
-
-    it "should pass along ssl when true" do
-      MongoMapper.config = {
-        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test', 'ssl' => true}
-      }
-      connection, logger = double('connection'), double('logger')
-      expect(Mongo::MongoClient).to receive(:new).with('127.0.0.1', 27017, :logger => logger, :ssl => true)
-      MongoMapper.connect('development', :logger => logger)
+      Mongo::Client.should_receive(:new).with(['127.0.0.1:27017'], {})
+      MongoMapper.connect('development')
     end
 
-    it "should pass along ssl when false" do
+    it "should work without authentication using host" do
       MongoMapper.config = {
-        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test', 'ssl' => false}
+        'development' => {'host' => '127.0.0.1:27017'}
       }
-      connection, logger = double('connection'), double('logger')
-      expect(Mongo::MongoClient).to receive(:new).with('127.0.0.1', 27017, :logger => logger, :ssl => false)
-      MongoMapper.connect('development', :logger => logger)
+      Mongo::Client.should_receive(:new).with(['127.0.0.1:27017'], {})
+      MongoMapper.connect('development')
     end
 
     it "should convert read preferences to symbols" do
       MongoMapper.config = {
-        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test', 'options' =>  {'read' => 'primary'}}
+        'development' => {'hosts' => ['127.0.0.1:27017'], 'database' => 'test', 'read' => 'primary'}
       }
-      connection, logger = double('connection'), double('logger')
-      expect(Mongo::MongoClient).to receive(:new).with('127.0.0.1', 27017, :logger => logger, :read => :primary)
+      logger = double('logger')
+      Mongo::Client.should_receive(:new).with(['127.0.0.1:27017'], :logger => logger, :read => :primary, :database => 'test')
       MongoMapper.connect('development', :logger => logger)
     end
 
     it "should work with options from config" do
       MongoMapper.config = {
-        'development' => {'host' => '192.168.1.1', 'port' => 2222, 'database' => 'test', 'options' => {'safe' => true}}
+        'development' => {'hosts' => ['192.168.1.1:2222'], 'database' => 'test', 'safe' => true}
       }
-      connection, logger = double('connection'), double('logger')
-      expect(Mongo::MongoClient).to receive(:new).with('192.168.1.1', 2222, :logger => logger, :safe => true)
+      logger = double('logger')
+      Mongo::Client.should_receive(:new).with(['192.168.1.1:2222'], :logger => logger, :safe => true, :database => 'test')
       MongoMapper.connect('development', :logger => logger)
     end
 
     it "should work with options using uri" do
       MongoMapper.config = {
-        'development' => {'uri' => 'mongodb://127.0.0.1:27017/test'}
+        'development' => {'uri' => 'mongodb://127.0.0.1:27017/test', 'options'=> {:foo => 1}}
       }
-      connection, logger = double('connection'), double('logger')
-      expect(Mongo::MongoClient).to receive(:new).with('127.0.0.1', 27017, :logger => logger)
+      logger = double('logger')
+      Mongo::Client.should_receive(:new).with('mongodb://127.0.0.1:27017/test', :logger => logger, :foo => 1)
       MongoMapper.connect('development', :logger => logger)
     end
 
     it "should work with authentication" do
       MongoMapper.config = {
-        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test', 'username' => 'john', 'password' => 'secret'}
+        'development' => {'hosts' => ['127.0.0.1:27017'], 'database' => 'test', 'user' => 'john', 'password' => 'secret'}
       }
-      expect_any_instance_of(Mongo::DB).to receive(:authenticate).with('john', 'secret')
+      Mongo::Client.should_receive(:new).with(['127.0.0.1:27017'], :database => 'test', :user => 'john', :password => 'secret')
       MongoMapper.connect('development')
     end
 
@@ -132,7 +105,7 @@ describe "MongoMapper" do
       MongoMapper.config = {
         'development' => {'uri' => 'mongodb://john:secret@127.0.0.1:27017/test'}
       }
-      expect_any_instance_of(Mongo::DB).to receive(:authenticate).with('john', 'secret')
+      Mongo::Client.should_receive(:new).with('mongodb://john:secret@127.0.0.1:27017/test', {})
       MongoMapper.connect('development')
     end
 
@@ -140,44 +113,24 @@ describe "MongoMapper" do
       MongoMapper.config = {
         'development' => {'uri' => 'mysql://127.0.0.1:5336/foo'}
       }
-      expect { MongoMapper.connect('development') }.to raise_error(MongoMapper::InvalidScheme)
+      lambda { MongoMapper.connect('development') }.should raise_error(Mongo::Error::InvalidURI)
     end
 
-    it "should create a replica set connection if config contains multiple hosts in the old format" do
+    it 'should forbid use of port' do
       MongoMapper.config = {
-        'development' => {
-          'hosts' => [ ['127.0.0.1', 27017], ['localhost', 27017] ],
-          'database' => 'test'
-        }
+        'development' => {'host' => '192.168.1.1', 'port' => '27017', 'database' => 'test', 'safe' => true}
       }
-
-      expect(Mongo::MongoReplicaSetClient).to receive(:new).with( ['127.0.0.1', 27017], ['localhost', 27017], {'read_secondary' => true} )
-      expect(MongoMapper).to receive(:database=).with('test')
-      expect_any_instance_of(Mongo::DB).to receive(:authenticate).never
-      MongoMapper.connect('development', 'read_secondary' => true)
+      lambda { MongoMapper.connect('development') }.should raise_error(RuntimeError)
     end
 
-    it "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'
-        }
-      }
-
-      expect(Mongo::MongoReplicaSetClient).to receive(:new).with( ['127.0.0.1:27017', 'localhost:27017'], {'read_secondary' => true} )
-      expect(MongoMapper).to receive(:database=).with('test')
-      expect_any_instance_of(Mongo::DB).to receive(:authenticate).never
-      MongoMapper.connect('development', 'read_secondary' => true)
-    end
   end
 
   context "setup" do
     it "should work as shortcut for setting config, environment and options" do
       config, logger = double('config'), double('logger')
-      expect(MongoMapper).to receive(:config=).with(config)
-      expect(MongoMapper).to receive(:connect).with('development', :logger => logger)
-      expect(MongoMapper).to receive(:handle_passenger_forking).once
+      MongoMapper.should_receive(:config=).with(config)
+      MongoMapper.should_receive(:connect).with('development', :logger => logger)
+      MongoMapper.should_receive(:handle_passenger_forking).once
       MongoMapper.setup(config, 'development', :logger => logger)
     end
   end