mongify 1.3.2 → 1.4.1

data/lib/mongify/database/data_row.rb

@@ -43,9 +43,9 @@ module Mongify
       end
 
       # Updated respond_to to return true if it's a key the hash
-      def respond_to?(method)
-        return true if @hash.has_key?(method.gsub('=', ''))
-        super(method)
+      def respond_to?(method, include_private = false)
+        return true if @hash.has_key?(method.to_s.gsub('=', ''))
+        super
       end
 
       # Added the ability to read and write attributes in the hash

data/lib/mongify/database/no_sql_connection.rb

@@ -25,8 +25,6 @@ module Mongify
     # <em>You're also able to set attributes via the options</em>
     #
     class NoSqlConnection < Mongify::Database::BaseConnection
-      include Mongo
-
 
       #Required fields for a no sql connection
       REQUIRED_FIELDS = %w{host database}
@@ -61,14 +59,20 @@ module Mongify
         !!@options['force']
       end
 
-      # Sets up a connection to the database
+      # Sets up a connection to the database using Mongo::Client (2.x driver)
       def setup_connection_adapter
-        connection = Connection.new(host, port)
-        connection.add_auth(database, username, password) if username && password
-        connection
+        hosts = ["#{host}:#{port || 27017}"]
+        client_options = { database: database }
+
+        if username && password
+          client_options[:user] = username
+          client_options[:password] = password
+        end
+
+        Mongo::Client.new(hosts, client_options)
       end
 
-      # Returns a mongo connection
+      # Returns a mongo client connection
       # NOTE: If forced? is true, the first time a connection is made, it will ask to drop the
       # database before continuing
       def connection
@@ -77,33 +81,46 @@ module Mongify
         @connection
       end
 
+      # Alias for connection to make code more readable with 2.x driver
+      alias_method :client, :connection
+
       # Returns true or false depending if we have a connection to a mongo server
       def has_connection?
-        connection.connected?
+        # In mongo 2.x, we ping the server to check connectivity
+        begin
+          client.database.command(ping: 1)
+          true
+        rescue Mongo::Error => e
+          false
+        end
       end
 
       # Returns the database from the connection
       def db
-        @db ||= connection[database]
+        @db ||= client.database
       end
 
       # Returns a hash of all the rows from the database of a given collection
       def select_rows(collection)
-        db[collection].find
+        client[collection].find
       end
 
       def select_by_query(collection, query)
-        db[collection].find(query)
+        client[collection].find(query)
       end
 
-      # Inserts into the collection a given row
-      def insert_into(colleciton_name, row)
-        db[colleciton_name].insert(row)
+      # Inserts into the collection a given row or array of rows
+      def insert_into(collection_name, row)
+        if row.is_a?(Array)
+          client[collection_name].insert_many(row)
+        else
+          client[collection_name].insert_one(row)
+        end
       end
 
       # Updates a collection item with a given ID with the given attributes
-      def update(colleciton_name, id, attributes)
-        db[colleciton_name].update({"_id" => id}, attributes)
+      def update(collection_name, id, attributes)
+        client[collection_name].replace_one({"_id" => id}, attributes)
       end
 
       # Upserts into the collection a given row
@@ -112,8 +129,6 @@ module Mongify
         # The reason is that it detects duplicates using _id
         # but we should detect it using pre_mongified_id instead
         # because in the case of sync, same rows are identified by their original sql ids
-        #
-        # db[collection_name].save(row)
 
         if row.has_key?(:pre_mongified_id) || row.has_key?('pre_mongified_id')
           id = row[:pre_mongified_id] || row['pre_mongified_id']
@@ -124,25 +139,31 @@ module Mongify
             insert_into(collection_name, row)
           end
         else
-          # no pre_mongified_id, fallback to the upsert method of Mongo
-          db[collection_name].save(row)
+          # no pre_mongified_id, use replace_one with upsert option
+          if row[:_id] || row["_id"]
+            id = row[:_id] || row["_id"]
+            client[collection_name].replace_one({"_id" => id}, row, upsert: true)
+          else
+            insert_into(collection_name, row)
+          end
         end
       end
 
       # Finds one item from a collection with the given query
       def find_one(collection_name, query)
-        db[collection_name].find_one(query)
+        client[collection_name].find(query).first
       end
 
       # Returns a row of a item from a given collection with a given pre_mongified_id
-      def get_id_using_pre_mongified_id(colleciton_name, pre_mongified_id)
-        db[colleciton_name].find_one('pre_mongified_id' => pre_mongified_id).try(:[], '_id')
+      def get_id_using_pre_mongified_id(collection_name, pre_mongified_id)
+        doc = client[collection_name].find('pre_mongified_id' => pre_mongified_id).first
+        doc ? doc['_id'] : nil
       end
 
       # Removes pre_mongified_id from all records in a given collection
       def remove_pre_mongified_ids(collection_name)
         drop_mongified_index(collection_name)
-        db[collection_name].update({}, { '$unset' => { 'pre_mongified_id' => 1} }, :multi => true)
+        client[collection_name].update_many({}, { '$unset' => { 'pre_mongified_id' => 1} })
       end
 
       # Removes pre_mongified_id from collection
@@ -150,13 +171,16 @@ module Mongify
       # @return True if successful
       # @raise MongoDBError if index isn't found
       def drop_mongified_index(collection_name)
-        db[collection_name].drop_index('pre_mongified_id_1') if db[collection_name].index_information.keys.include?("pre_mongified_id_1")
+        index_names = client[collection_name].indexes.collect { |idx| idx['name'] }
+        if index_names.include?("pre_mongified_id_1")
+          client[collection_name].indexes.drop_one('pre_mongified_id_1')
+        end
       end
 
       # Creates a pre_mongified_id index to ensure
       # speedy lookup for collections via the pre_mongified_id
       def create_pre_mongified_id_index(collection_name)
-        db[collection_name].create_index([['pre_mongified_id', Mongo::ASCENDING]])
+        client[collection_name].indexes.create_one({ 'pre_mongified_id' => 1 })
       end
 
       # Asks user permission to drop the database
@@ -173,7 +197,7 @@ module Mongify
 
       # Drops the mongodb database
       def drop_database
-        connection.drop_database(database)
+        client.database.drop
       end
 
 

data/lib/mongify/translation/sync.rb

@@ -10,7 +10,7 @@ module Mongify
       DRAFT_KEY = "__mongify_sync_draft__"
       SYNC_HELPER_TABLE = "__mongify_sync_helper__"
 
-      class SyncHelperMigrator < ActiveRecord::Migration
+      class SyncHelperMigrator < ActiveRecord::Migration[5.0]
         def up
           create_table SYNC_HELPER_TABLE, :id => false do |t|
             t.string :table_name

data/lib/mongify/version.rb

@@ -1,4 +1,4 @@
 module Mongify
   # Mongify's Current Version Number
-  VERSION = "1.3.2"
+  VERSION = "1.4.1".freeze
 end

data/lib/mongify.rb

@@ -1,6 +1,7 @@
 #
 # Mongify's core functionality
 #
+require "logger"
 require 'active_support'
 require 'active_support/core_ext'
 require 'active_record'

data/mongify.gemspec

@@ -10,24 +10,23 @@ Gem::Specification.new do |s|
   s.homepage    = "http://mongify.com"
   s.summary     = %q{Translate your SQL data to MongoDB with ease}
   s.description = %q{Mongify allows you to map your sql data into a mongodb document database with a simple DSL.}
-  s.required_ruby_version = ">= 1.8.7"
+  s.required_ruby_version = ">= 3.0"
 
-  s.add_runtime_dependency('activerecord', ">= 4.2", "< 5.0")
-  s.add_runtime_dependency('activesupport', ">= 4.2", "< 5.0")
-  s.add_runtime_dependency('mongo', "= 1.12.5")
-  s.add_runtime_dependency('bson', "= 1.12.5")
-  s.add_runtime_dependency('bson_ext', "= 1.12.5") unless RUBY_PLATFORM == 'java'
-  s.add_runtime_dependency('highline', '= 1.7.8')
+  s.add_runtime_dependency('activerecord', ">= 7.1.5.2", "< 8.0")
+  s.add_runtime_dependency('activesupport', ">= 7.1.5.2", "< 8.0")
+  s.add_runtime_dependency('mongo', "~> 2.19")
+  s.add_runtime_dependency('highline', '>= 1.7.8')
+  s.add_runtime_dependency('abbrev')  # Required for Ruby 3.4+ (removed from stdlib)
 
 
-  s.add_development_dependency('rspec', '~> 2.0')
+  s.add_development_dependency('rspec', '~> 3.0')
   s.add_development_dependency('rspec-collection_matchers', '~> 1.0')
-  s.add_development_dependency('cucumber', '>= 0.10')
+  s.add_development_dependency('cucumber', '>= 9.0')
   s.add_development_dependency('mocha', '>= 0.9.8')
-  s.add_development_dependency('yard', '>= 0.8')
+  s.add_development_dependency('yard', '~> 0.9.11')
   s.add_development_dependency('sqlite3', '>= 1.3')
   s.add_development_dependency('pg', '>= 0.17')
-  s.add_development_dependency('mysql2', '>= 0.4')
+  s.add_development_dependency('mysql2', '>= 0.4.10')
   s.add_development_dependency('watchr', '>= 0.6')
   s.add_development_dependency('rake')
   s.add_development_dependency('jazz_fingers')

data/spec/mongify/cli/command/version_spec.rb

@@ -8,7 +8,7 @@ describe Mongify::CLI::Command::Version do
   end
 
   it 'displays the text on the view' do
-    @view.expects(:output).with(/#{@text}/)
+    @view.should_receive(:output).with(/#{@text}/)
     @cmd.execute(@view)
   end
 

data/spec/mongify/database/base_connection_spec.rb

@@ -35,7 +35,7 @@ describe Mongify::Database::BaseConnection do
   end
 
   it "should raise error on setting unknown variable setting" do
-    lambda{@base_connection.connection = "localhost"}.should raise_error
+    lambda{@base_connection.connection = "localhost"}.should raise_error(NoMethodError)
   end
 
   it "should respond to available settings" do

data/spec/mongify/database/no_sql_connection_spec.rb

@@ -48,47 +48,63 @@ describe Mongify::Database::NoSqlConnection do
 
   context "connection" do
     before(:each) do
-      @mock_connection = double(:connected? => true)
-      Mongo::Connection.stub(:new).and_return(@mock_connection)
+      @mock_client = double('Mongo::Client')
+      @mock_database = double('Mongo::Database')
+      @mock_client.stub(:database).and_return(@mock_database)
+      @mock_database.stub(:command).and_return(double)
+      Mongo::Client.stub(:new).and_return(@mock_client)
     end
 
     it "should only create a connection once" do
-      Mongo::Connection.should_receive(:new).once
+      Mongo::Client.should_receive(:new).once
+      @mongodb_connection.host 'localhost'
+      @mongodb_connection.database 'test'
       @mongodb_connection.connection
       @mongodb_connection.connection
     end
 
-    it "should add_auth if username && password is present" do
-      @mock_connection.should_receive(:add_auth)
+    it "should include credentials in client options if username && password is present" do
+      @mongodb_connection.host 'localhost'
+      @mongodb_connection.database 'test'
       @mongodb_connection.username "bob"
       @mongodb_connection.password "secret"
+      Mongo::Client.should_receive(:new).with(
+        ["localhost:27017"],
+        hash_including(user: "bob", password: "secret", database: "test")
+      ).and_return(@mock_client)
       @mongodb_connection.connection
     end
-
   end
 
 
   context "database action:" do
     before(:each) do
-       @collection = double
-       @db = double
-       @db.stub(:[]).with('users').and_return(@collection)
-       @mongodb_connection.stub(:db).and_return(@db)
+      @mongodb_connection.host 'localhost'
+      @mongodb_connection.database 'test'
+      @collection = double('collection')
+      @mock_client = double('Mongo::Client')
+      @mock_client.stub(:[]).with('users').and_return(@collection)
+      @mongodb_connection.stub(:client).and_return(@mock_client)
     end
+
     context "insert_into" do
       it "should insert into a table using the mongo driver" do
-        @collection.should_receive(:insert).with({'first_name' => 'bob'})
+        @collection.should_receive(:insert_one).with({'first_name' => 'bob'})
         @mongodb_connection.insert_into('users', {'first_name' => 'bob'})
       end
     end
 
     context "get_id_using_pre_mongified_id" do
       it "should return new id" do
-        @collection.should_receive(:find_one).with({"pre_mongified_id"=>1}).and_return({'_id' => '123'})
+        cursor = double('cursor')
+        cursor.stub(:first).and_return({'_id' => '123'})
+        @collection.should_receive(:find).with({"pre_mongified_id"=>1}).and_return(cursor)
         @mongodb_connection.get_id_using_pre_mongified_id('users', 1).should == '123'
       end
       it "should return nil if nothing is found" do
-        @collection.should_receive(:find_one).with({"pre_mongified_id"=>1}).and_return(nil)
+        cursor = double('cursor')
+        cursor.stub(:first).and_return(nil)
+        @collection.should_receive(:find).with({"pre_mongified_id"=>1}).and_return(cursor)
         @mongodb_connection.get_id_using_pre_mongified_id('users', 1).should == nil
       end
     end
@@ -111,7 +127,7 @@ describe Mongify::Database::NoSqlConnection do
     context "update" do
       it "should update the record" do
         attributes = {'post_id' => 123}
-        @collection.should_receive(:update).with({"_id" => 1}, attributes)
+        @collection.should_receive(:replace_one).with({"_id" => 1}, attributes)
         @mongodb_connection.update('users', 1, attributes)
       end
     end
@@ -135,38 +151,50 @@ describe Mongify::Database::NoSqlConnection do
         @mongodb_connection.upsert('users', attributes)
       end
 
-      it "should delegate the upsert to the save method of Mongo if no pre_mongified_id to match with the _id" do
+      it "should use replace_one with upsert if _id is present but no pre_mongified_id" do
+        attributes = {'_id' => 'abc123', 'post_id' => 123}
+        @collection.should_receive(:replace_one).with({"_id" => 'abc123'}, attributes, upsert: true)
+        @mongodb_connection.upsert('users', attributes)
+      end
+
+      it "should insert if no _id and no pre_mongified_id" do
         attributes = {'post_id' => 123}
-        @collection.should_receive(:save).with(attributes)
+        @mongodb_connection.should_receive(:insert_into).with('users', attributes)
         @mongodb_connection.upsert('users', attributes)
       end
     end
 
     context "find_one" do
-      it "should call find_one on collection" do
-        query= {'pre_mongified_id' => 1}
-        @collection.should_receive(:find_one).with(query)
+      it "should call find and return first result" do
+        query = {'pre_mongified_id' => 1}
+        cursor = double('cursor')
+        cursor.stub(:first).and_return({'_id' => '123'})
+        @collection.should_receive(:find).with(query).and_return(cursor)
         @mongodb_connection.find_one('users', query)
       end
     end
 
     it "should create index for pre_mongified_id" do
-      @collection.should_receive(:create_index).with([["pre_mongified_id", Mongo::ASCENDING]]).and_return(true)
+      indexes = double('indexes')
+      @collection.stub(:indexes).and_return(indexes)
+      indexes.should_receive(:create_one).with({ 'pre_mongified_id' => 1 }).and_return(true)
       @mongodb_connection.create_pre_mongified_id_index('users')
     end
 
     context "remove_pre_mongified_ids" do
       before(:each) do
-        @collection.stub(:index_information).and_return('pre_mongified_id_1' => 'something')
+        @indexes = double('indexes')
+        @indexes.stub(:collect).and_return(['pre_mongified_id_1'])
+        @collection.stub(:indexes).and_return(@indexes)
       end
-      it "should call update with unset" do
-        @collection.should_receive(:update).with({},{'$unset' => {'pre_mongified_id' => 1}}, {:multi=>true})
-        @collection.stub(:drop_index)
+      it "should call update_many with unset" do
+        @collection.should_receive(:update_many).with({},{'$unset' => {'pre_mongified_id' => 1}})
+        @indexes.stub(:drop_one)
         @mongodb_connection.remove_pre_mongified_ids('users')
       end
       it "should drop the index" do
-        @collection.should_receive(:drop_index).with('pre_mongified_id_1')
-        @collection.stub(:update)
+        @indexes.should_receive(:drop_one).with('pre_mongified_id_1')
+        @collection.stub(:update_many)
         @mongodb_connection.remove_pre_mongified_ids('users')
       end
     end
@@ -174,8 +202,12 @@ describe Mongify::Database::NoSqlConnection do
 
   context "force" do
     before(:each) do
-      @mock_connection = double(:connected? => true, :drop_database => true)
-      Mongo::Connection.stub(:new).and_return(@mock_connection)
+      @mock_client = double('Mongo::Client')
+      @mock_database = double('Mongo::Database')
+      @mock_client.stub(:database).and_return(@mock_database)
+      @mock_database.stub(:command).and_return(double)
+      @mock_database.stub(:drop).and_return(true)
+      Mongo::Client.stub(:new).and_return(@mock_client)
       @mongodb_connection = Mongify::Database::NoSqlConnection.new(:host => 'localhost', :database => 'blue', :force => true)
       Mongify::UI.stub(:ask).and_return(true)
     end
@@ -187,7 +219,7 @@ describe Mongify::Database::NoSqlConnection do
     end
 
     it "should drop database" do
-      @mongodb_connection.connection.should_receive(:drop_database).with('blue').and_return(true)
+      @mock_database.should_receive(:drop).and_return(true)
       @mongodb_connection.send(:drop_database)
     end
 
@@ -221,9 +253,8 @@ describe Mongify::Database::NoSqlConnection do
     end
 
     it "should return a db" do
-      @mongodb_connection.db.should be_a Mongify::Database::NoSqlConnection::DB
+      @mongodb_connection.db.should be_a Mongo::Database
     end
   end
 
 end
-

data/spec/spec_helper.rb

@@ -22,9 +22,14 @@ Mongify.root = File.dirname(File.dirname(__FILE__))
 
 ::DATABASE_PRINT = File.read(File.dirname(File.expand_path(__FILE__)) + '/support/database_output.txt')
 
-# redirect deprecation warnings of rspec to a file
-RSpec.configure do |rspec|
-  rspec.deprecation_stream = 'log/deprecations.log'
+# Enable legacy :should syntax for backwards compatibility
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+  config.mock_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
 end
 # mute the deprecation message from I18n
 I18n.enforce_available_locales = false

data/spec/support/config_reader.rb

@@ -1,7 +1,7 @@
 # Used during testing to read in a config file
 class ConfigReader
   def initialize(filepath)
-    if File.exists?(filepath)
+    if File.exist?(filepath)
       config = YAML.load_file(filepath)
       config.each { |key, value| instance_variable_set("@#{key}", value) }
     else

data/spec/support/database.example

@@ -7,7 +7,7 @@ mysql:
   database: mongify_test
   username: root
   password: passw0rd
-  host: localhost
+  host: 127.0.0.1
   port: 3306
 
 postgresql:

data/spec/support/database_generator.rb

@@ -31,7 +31,7 @@ class DatabaseGenerator
 
   # Creates a new mysql database (and deletes the old one)
   def self.sqlite(include_data=true)
-    File.delete(sqlite_connection.database) if File.exists?(sqlite_connection.database)
+    File.delete(sqlite_connection.database) if File.exist?(sqlite_connection.database)
 
     conn = sqlite_connection.connection
 
@@ -91,17 +91,17 @@ class DatabaseGenerator
         {:first_name => 'Bob', :last_name => 'Smith'},
         {:first_name => 'Joe', :last_name => 'Franklin'}
       ].each do |values|
-        conn.insert("INSERT INTO users (first_name, last_name, created_at, updated_at) VALUES ('#{values[:first_name]}', '#{values[:last_name]}', '#{Time.now.to_s(:db)}', '#{Time.now.to_s(:db)}')")
+        conn.insert("INSERT INTO users (first_name, last_name, created_at, updated_at) VALUES ('#{values[:first_name]}', '#{values[:last_name]}', '#{Time.now.to_fs(:db)}', '#{Time.now.to_fs(:db)}')")
       end
 
       #Posts
       [
-        {:title => 'First Post', :owner_id => 1, :body => 'First Post Body', :published_at => (Time.now - 2).to_s(:db)},
-        {:title => 'Second Post', :owner_id => 1, :body => 'Second Post Body', :published_at => (Time.now - 1).to_s(:db)},
-        {:title => 'Third Post', :owner_id => 2, :body => 'Third Post Body', :published_at => (Time.now).to_s(:db)},
+        {:title => 'First Post', :owner_id => 1, :body => 'First Post Body', :published_at => (Time.now - 2).to_fs(:db)},
+        {:title => 'Second Post', :owner_id => 1, :body => 'Second Post Body', :published_at => (Time.now - 1).to_fs(:db)},
+        {:title => 'Third Post', :owner_id => 2, :body => 'Third Post Body', :published_at => (Time.now).to_fs(:db)},
       ].each do |v|
         conn.insert("INSERT INTO posts (title, owner_id, body, published_at, created_at, updated_at)
-                    VALUES ('#{v[:title]}', #{v[:owner_id]}, '#{v[:body]}', '#{v[:published_at]}', '#{Time.now.to_s(:db)}', '#{Time.now.to_s(:db)}')")
+                    VALUES ('#{v[:title]}', #{v[:owner_id]}, '#{v[:body]}', '#{v[:published_at]}', '#{Time.now.to_fs(:db)}', '#{Time.now.to_fs(:db)}')")
       end
 
       #Comments
@@ -111,7 +111,7 @@ class DatabaseGenerator
         {:post_id => 2, :user_id => 2, :body => 'Third Comment Body'},
       ].each do |v|
         conn.insert("INSERT INTO comments (body, post_id, user_id, created_at, updated_at)
-                    VALUES ('#{v[:body]}', #{v[:post_id]}, #{v[:user_id]}, '#{Time.now.to_s(:db)}', '#{Time.now.to_s(:db)}')")
+                    VALUES ('#{v[:body]}', #{v[:post_id]}, #{v[:user_id]}, '#{Time.now.to_fs(:db)}', '#{Time.now.to_fs(:db)}')")
       end
 
       #Preferences
@@ -121,7 +121,7 @@ class DatabaseGenerator
         {:user_id => 3, :notify_by_email => false},
       ].each_with_index do |v, idx|
           conn.insert("INSERT INTO preferences (id, user_id, notify_by_email, created_at, updated_at)
-                      VALUES ('p#{idx+1}',#{v[:user_id]}, '#{v[:notify_by_email]}', '#{Time.now.to_s(:db)}', '#{Time.now.to_s(:db)}')")
+                      VALUES ('p#{idx+1}',#{v[:user_id]}, '#{v[:notify_by_email]}', '#{Time.now.to_fs(:db)}', '#{Time.now.to_fs(:db)}')")
       end
 
       #Notes
@@ -132,7 +132,7 @@ class DatabaseGenerator
         {:user_id => 3, :body => 'note 4', :notable_id => 2, :notable_type => 'User'},
       ].each do |v|
           conn.insert("INSERT INTO notes (user_id, body, notable_id, notable_type, created_at, updated_at)
-                      VALUES (#{v[:user_id]}, '#{v[:body]}', #{v[:notable_id]}, '#{v[:notable_type]}', '#{Time.now.to_s(:db)}', '#{Time.now.to_s(:db)}')")
+                      VALUES (#{v[:user_id]}, '#{v[:body]}', #{v[:notable_id]}, '#{v[:notable_type]}', '#{Time.now.to_fs(:db)}', '#{Time.now.to_fs(:db)}')")
       end
 
       #Teams
@@ -142,7 +142,7 @@ class DatabaseGenerator
         {:name => 'Copenhagen Crushers', :phone => '+1112223334'}
       ].each do |v|
         conn.insert("INSERT INTO teams (name, phone, created_at, updated_at)
-                    VALUES ('#{v[:name]}', '#{v[:phone]}', '#{Time.now.to_s(:db)}', '#{Time.now.to_s(:db)}')")
+                    VALUES ('#{v[:name]}', '#{v[:phone]}', '#{Time.now.to_fs(:db)}', '#{Time.now.to_fs(:db)}')")
       end
 
       #Coaches
@@ -152,7 +152,7 @@ class DatabaseGenerator
         {:team_id => 3, :first_name => 'Carl', :last_name => 'Cooper'}
       ].each do |v|
         conn.insert("INSERT INTO coaches (team_id, first_name, last_name, created_at, updated_at)
-                    VALUES (#{v[:team_id]}, '#{v[:first_name]}', '#{v[:last_name]}', '#{Time.now.to_s(:db)}', '#{Time.now.to_s(:db)}')")
+                    VALUES (#{v[:team_id]}, '#{v[:first_name]}', '#{v[:last_name]}', '#{Time.now.to_fs(:db)}', '#{Time.now.to_fs(:db)}')")
       end
 
     end
@@ -162,7 +162,7 @@ class DatabaseGenerator
 
   # Drops the database in mongo
   def self.clear_mongodb
-    mongo_connection.connection.drop_database mongo_connection.database
+    mongo_connection.db.drop
   end
 
   # Returns a mongo connection (based on the database.yml)