jonbell-mongo 1.3.1.2

data/mongo.gemspec

@@ -0,0 +1,34 @@
+require "./lib/mongo"
+
+Gem::Specification.new do |s|
+  s.name = 'jonbell-mongo'
+
+  s.version = Mongo::VERSION + ".2"
+
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'Ruby driver for the MongoDB'
+  s.description = 'A Ruby driver for MongoDB. For more information about Mongo, see http://www.mongodb.org.'
+
+  s.require_paths = ['lib']
+
+  s.files  = ['README.md', 'Rakefile', 'mongo.gemspec', 'LICENSE.txt']
+  s.files += ['lib/mongo.rb'] + Dir['lib/mongo/**/*.rb']
+  s.files += Dir['docs/**/*.md'] + Dir['examples/**/*.rb'] + Dir['bin/**/*.rb']
+  s.files += Dir['bin/mongo_console']
+  s.test_files = Dir['test/**/*.rb']
+
+  s.executables = ['mongo_console']
+
+  s.has_rdoc = true
+  s.test_files = Dir['test/**/*.rb']
+
+  s.has_rdoc = true
+  s.rdoc_options = ['--main', 'README.md', '--inline-source']
+  s.extra_rdoc_files = ['README.md']
+
+  s.authors = ['Jim Menard', 'Mike Dirolf', 'Kyle Banker']
+  s.email = 'mongodb-dev@googlegroups.com'
+  s.homepage = 'http://www.mongodb.org'
+
+  s.add_dependency(%q<bson>, [">= #{Mongo::VERSION}"])
+end

data/test/auxillary/1.4_features.rb

@@ -0,0 +1,166 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'mongo'
+require 'test/unit'
+require './test/test_helper'
+
+# Demonstrate features in MongoDB 1.4
+class Features14Test < Test::Unit::TestCase
+
+  context "MongoDB 1.4" do
+    setup do
+      @con = Mongo::Connection.new
+      @db  = @con['mongo-ruby-test']
+      @col = @db['new-features']
+    end
+
+    teardown do
+      @col.drop
+    end
+
+    context "new query operators: " do
+
+      context "$elemMatch: " do
+        setup do
+          @col.save({:user => 'bob', :updates => [{:date => Time.now.utc, :body => 'skiing', :n => 1},
+                                                  {:date => Time.now.utc, :body => 'biking', :n => 2}]})
+
+          @col.save({:user => 'joe', :updates => [{:date => Time.now.utc, :body => 'skiing', :n => 2},
+                                                  {:date => Time.now.utc, :body => 'biking', :n => 10}]})
+        end
+
+        should "match a document with a matching object element in an array" do
+          doc = @col.find_one({"updates" => {"$elemMatch" => {"body" => "skiing", "n" => 2}}})
+          assert_equal 'joe', doc['user']
+        end
+
+        should "$elemMatch with a conditional operator" do
+          doc1 = @col.find_one({"updates" => {"$elemMatch" => {"body" => "biking", "n" => {"$gt" => 5}}}})
+          assert_equal 'joe', doc1['user']
+        end
+
+        should "note the difference between $elemMatch and a traditional match" do
+          doc = @col.find({"updates.body" => "skiing", "updates.n" => 2}).to_a
+          assert_equal 2, doc.size
+        end
+      end
+
+      context "$all with regexes" do
+        setup do
+          @col.save({:n => 1, :a => 'whale'})
+          @col.save({:n => 2, :a => 'snake'})
+        end
+
+        should "match multiple regexes" do
+          doc = @col.find({:a => {'$all' => [/ha/, /le/]}}).to_a
+          assert_equal 1, doc.size
+          assert_equal 1, doc.first['n']
+        end
+
+        should "not match if not every regex matches" do
+          doc = @col.find({:a => {'$all' => [/ha/, /sn/]}}).to_a
+          assert_equal 0, doc.size
+        end
+      end
+
+      context "the $not operator" do
+        setup do
+          @col.save({:a => ['x']})
+          @col.save({:a => ['x', 'y']})
+          @col.save({:a => ['x', 'y', 'z']})
+        end
+
+        should "negate a standard operator" do
+          results = @col.find({:a => {'$not' => {'$size' => 2}}}).to_a
+          assert_equal 2, results.size
+          results = results.map {|r| r['a']}
+          assert_equal ['x'], results.sort.first
+          assert_equal ['x', 'y', 'z'], results.sort.last
+        end
+      end
+    end
+
+    context "new update operators: " do
+
+      context "$addToSet (pushing a unique value)" do
+        setup do
+          @col.save({:username => 'bob', :interests => ['skiing', 'guitar']})
+        end
+
+        should "add an item to a set uniquely ($addToSet)" do
+          @col.update({:username => 'bob'}, {'$addToSet' => {'interests' => 'skiing'}})
+          @col.update({:username => 'bob'}, {'$addToSet' => {'interests' => 'kayaking'}})
+          document = @col.find_one({:username => 'bob'})
+          assert_equal ['guitar', 'kayaking', 'skiing'], document['interests'].sort
+        end
+
+        should "add an array of items uniquely ($addToSet with $each)" do
+          @col.update({:username => 'bob'}, {'$addToSet' => {'interests' => {'$each' => ['skiing', 'kayaking', 'biking']}}})
+          document = @col.find_one({:username => 'bob'})
+          assert_equal ['biking', 'guitar', 'kayaking', 'skiing'], document['interests'].sort
+        end
+      end
+
+      context "the positional operator ($)" do
+        setup do
+          @id1 = @col.insert({:text => 'hello',
+                             :comments => [{'by'   => 'bob',
+                                            'text' => 'lol!'},
+                                           {'by'   => 'susie',
+                                            'text' => 'bye bye!'}]})
+          @id2 = @col.insert({:text => 'goodbye',
+                            :comments => [{'by'   => 'bob',
+                                           'text' => 'au revoir'},
+                                          {'by'   => 'susie',
+                                           'text' => 'bye bye!'}]})
+        end
+
+        should "update a matching array item" do
+          @col.update({"_id" => @id1, "comments.by" => 'bob'}, {'$set' => {'comments.$.text' => 'lmao!'}}, :multi => true)
+          result = @col.find_one({"_id" => @id1})
+          assert_equal 'lmao!', result['comments'][0]['text']
+        end
+      end
+    end
+
+    context "Geoindexing" do
+      setup do
+        @places = @db['places']
+        @places.create_index([['loc', Mongo::GEO2D]])
+
+        @empire_state = ([40.748371, -73.985031])
+        @jfk = ([40.643711, -73.790009])
+
+        @places.insert({'name' => 'Empire State Building', 'loc' => ([40.748371, -73.985031])})
+        @places.insert({'name' => 'Flatiron Building', 'loc' => ([40.741581, -73.987549])})
+        @places.insert({'name' => 'Grand Central', 'loc' => ([40.751678, -73.976562])})
+        @places.insert({'name' => 'Columbia University', 'loc' => ([40.808922, -73.961617])})
+        @places.insert({'name' => 'NYSE', 'loc' => ([40.71455, -74.007124])})
+        @places.insert({'name' => 'JFK', 'loc' => ([40.643711, -73.790009])})
+      end
+
+      teardown do
+        @places.drop
+      end
+
+      should "find the nearest addresses" do
+        results = @places.find({'loc' => {'$near' => @empire_state}}).limit(2).to_a
+        assert_equal 2, results.size
+        assert_equal 'Empire State Building', results[0]['name']
+        assert_equal 'Flatiron Building', results[1]['name']
+      end
+
+      should "use geoNear command to return distances from a point" do
+        cmd = BSON::OrderedHash.new
+        cmd['geoNear'] = 'places'
+        cmd['near']    = @empire_state
+        cmd['num']     = 6
+        r = @db.command(cmd)
+
+        assert_equal 6, r['results'].length
+        r['results'].each do |result|
+          puts result.inspect
+        end
+      end
+    end
+  end
+end

data/test/auxillary/authentication_test.rb

@@ -0,0 +1,68 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'mongo'
+require 'test/unit'
+require './test/test_helper'
+
+# NOTE: This test requires bouncing the server.
+# It also requires that a user exists on the admin database.
+class AuthenticationTest < Test::Unit::TestCase
+  include Mongo
+
+  def setup
+    @conn = Mongo::Connection.new
+    @db1 = @conn.db('mongo-ruby-test-auth1')
+    @db2 = @conn.db('mongo-ruby-test-auth2')
+    @admin = @conn.db('admin')
+  end
+
+  def teardown
+    @db1.authenticate('user1', 'secret')
+    @db2.authenticate('user2', 'secret')
+    @conn.drop_database('mongo-ruby-test-auth1')
+    @conn.drop_database('mongo-ruby-test-auth2')
+  end
+
+  def test_authenticate
+    @admin.authenticate('bob', 'secret')
+    @db1.add_user('user1', 'secret')
+    @db2.add_user('user2', 'secret')
+    @admin.logout
+
+    assert_raise Mongo::OperationFailure do
+      @db1['stuff'].insert({:a => 2}, :safe => true)
+    end
+
+    assert_raise Mongo::OperationFailure do
+      @db2['stuff'].insert({:a => 2}, :safe => true)
+    end
+
+    @db1.authenticate('user1', 'secret')
+    @db2.authenticate('user2', 'secret')
+
+    assert @db1['stuff'].insert({:a => 2}, :safe => true)
+    assert @db2['stuff'].insert({:a => 2}, :safe => true)
+
+    puts "Please bounce the server."
+    gets
+
+    # Here we reconnect.
+    begin
+      @db1['stuff'].find.to_a
+      rescue Mongo::ConnectionFailure
+    end
+
+    assert @db1['stuff'].insert({:a => 2}, :safe => true)
+    assert @db2['stuff'].insert({:a => 2}, :safe => true)
+
+    @db1.logout
+    assert_raise Mongo::OperationFailure do
+      @db1['stuff'].insert({:a => 2}, :safe => true)
+    end
+
+    @db2.logout
+    assert_raise Mongo::OperationFailure do
+      assert @db2['stuff'].insert({:a => 2}, :safe => true)
+    end
+  end
+
+end

data/test/auxillary/autoreconnect_test.rb

@@ -0,0 +1,41 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'mongo'
+require 'test/unit'
+require './test/test_helper'
+
+# NOTE: This test requires bouncing the server
+class AutoreconnectTest < Test::Unit::TestCase
+  include Mongo
+
+  def setup
+    @conn = Mongo::Connection.new
+    @db = @conn.db('mongo-ruby-test')
+    @db.drop_collection("test-connect")
+    @coll = @db.collection("test-connect")
+  end
+
+  def test_query
+    @coll.save({:a => 20})
+    @coll.save({:a => 30})
+    @coll.save({:a => 40})
+    results = []
+    @coll.find.each {|r| results << r}
+    [20, 30, 40].each do |a|
+      assert results.any? {|r| r['a'] == a}, "Could not find record for a => #{a}"
+    end
+
+    puts "Please disconnect and then reconnect the current master."
+    gets
+
+    begin
+      @coll.find.to_a
+      rescue Mongo::ConnectionFailure
+    end
+
+    results = []
+      @coll.find.each {|r| results << r}
+      [20, 30, 40].each do |a|
+        assert results.any? {|r| r['a'] == a}, "Could not find record for a => #{a}"
+      end
+  end
+end

data/test/auxillary/fork_test.rb

@@ -0,0 +1,30 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'mongo'
+require 'test/unit'
+require './test/test_helper'
+
+class ForkTest < Test::Unit::TestCase
+  include Mongo
+
+  def setup
+    @conn = standard_connection
+  end
+
+  def test_fork
+    # Now insert some data
+    10.times do |n|
+      @conn[MONGO_TEST_DB]['nums'].insert({:a => n})
+    end
+
+    # Now fork. You'll almost always see an exception here.
+    if !Kernel.fork
+      10.times do
+        assert @conn[MONGO_TEST_DB]['nums'].find_one
+      end
+    else
+      10.times do
+        assert @conn[MONGO_TEST_DB]['nums'].find_one
+      end
+    end
+  end
+end

data/test/auxillary/repl_set_auth_test.rb

@@ -0,0 +1,58 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require './test/test_helper'
+require './test/tools/auth_repl_set_manager'
+
+class AuthTest < Test::Unit::TestCase
+  include Mongo
+
+  def setup
+    @manager = AuthReplSetManager.new(:start_port => 40000)
+    @manager.start_set
+  end
+
+  def teardown
+    @manager.cleanup_set
+  end
+
+  def test_repl_set_auth
+    @conn = ReplSetConnection.new([@manager.host, @manager.ports[0]], [@manager.host, @manager.ports[1]],
+      [@manager.host, @manager.ports[2]], :name => @manager.name)
+
+    # Add an admin user
+    @conn['admin'].add_user("me", "secret")
+
+    # Ensure that insert fails
+    assert_raise_error Mongo::OperationFailure, "unauthorized" do
+      @conn['foo']['stuff'].insert({:a => 2}, :safe => {:w => 3})
+    end
+
+    # Then authenticate
+    assert @conn['admin'].authenticate("me", "secret")
+
+    # Insert should succeed now
+    assert @conn['foo']['stuff'].insert({:a => 2}, :safe => {:w => 3})
+
+    # So should a query
+    assert @conn['foo']['stuff'].find_one
+
+    # But not when we logout
+    @conn['admin'].logout
+
+    assert_raise_error Mongo::OperationFailure, "unauthorized" do
+      @conn['foo']['stuff'].find_one
+    end
+
+    # Same should apply to a random secondary
+    @slave1 = Connection.new(@conn.secondary_pools[0].host,
+      @conn.secondary_pools[0].port, :slave_ok => true)
+
+    # Find should fail
+    assert_raise_error Mongo::OperationFailure, "unauthorized" do
+      @slave1['foo']['stuff'].find_one
+    end
+
+    # But not when authenticated
+    @slave1['admin'].authenticate("me", "secret")
+    assert @slave1['foo']['stuff'].find_one
+  end
+end

data/test/auxillary/slave_connection_test.rb

@@ -0,0 +1,36 @@
+require './test/test_helper'
+
+# NOTE: these tests are run only if we can connect to a single MongoDB in slave mode.
+class SlaveConnectionTest < Test::Unit::TestCase
+  include Mongo
+
+  def self.connect_to_slave
+    @@host = ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost'
+    @@port = ENV['MONGO_RUBY_DRIVER_PORT'] || Connection::DEFAULT_PORT
+    conn = Connection.new(@@host, @@port, :slave_ok => true)
+    response = conn['admin'].command(:ismaster => 1)
+    Mongo::Support.ok?(response) && response['ismaster'] != 1
+  end
+
+  if self.connect_to_slave
+    puts "Connected to slave; running slave tests."
+
+    def test_connect_to_slave
+      assert_raise Mongo::ConnectionFailure do
+        @db = Connection.new(@@host, @@port, :slave_ok => false).db('ruby-mongo-demo')
+      end
+    end
+
+    def test_slave_ok_sent_to_queries
+      @con = Connection.new(@@host, @@port, :slave_ok => true)
+      assert_equal true, @con.slave_ok?
+    end
+  else
+    puts "Not connected to slave; skipping slave connection tests."
+
+    def test_slave_ok_false_on_queries
+      @conn = Connection.new(@@host, @@port)
+      assert !@conn.slave_ok?
+    end
+  end
+end

data/test/auxillary/threaded_authentication_test.rb

@@ -0,0 +1,101 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'mongo'
+require 'thread'
+require 'test/unit'
+require './test/test_helper'
+
+# NOTE: This test requires bouncing the server.
+# It also requires that a user exists on the admin database.
+class AuthenticationTest < Test::Unit::TestCase
+  include Mongo
+
+  def setup
+    @conn = standard_connection(:pool_size => 10)
+    @db1 = @conn.db('mongo-ruby-test-auth1')
+    @db2 = @conn.db('mongo-ruby-test-auth2')
+    @admin = @conn.db('admin')
+  end
+
+  def teardown
+    @db1.authenticate('user1', 'secret')
+    @db2.authenticate('user2', 'secret')
+    @conn.drop_database('mongo-ruby-test-auth1')
+    @conn.drop_database('mongo-ruby-test-auth2')
+  end
+
+  def threaded_exec
+    threads = []
+
+    100.times do
+      threads << Thread.new do
+        yield
+      end
+    end
+
+    100.times do |n|
+      threads[n].join
+    end
+  end
+
+  def test_authenticate
+    @admin.authenticate('bob', 'secret')
+    @db1.add_user('user1', 'secret')
+    @db2.add_user('user2', 'secret')
+    @admin.logout
+
+    threaded_exec do
+      assert_raise Mongo::OperationFailure do
+        @db1['stuff'].insert({:a => 2}, :safe => true)
+      end
+    end
+
+    threaded_exec do
+      assert_raise Mongo::OperationFailure do
+        @db2['stuff'].insert({:a => 2}, :safe => true)
+      end
+    end
+
+    @db1.authenticate('user1', 'secret')
+    @db2.authenticate('user2', 'secret')
+
+    threaded_exec do
+      assert @db1['stuff'].insert({:a => 2}, :safe => true)
+    end
+
+    threaded_exec do
+      assert @db2['stuff'].insert({:a => 2}, :safe => true)
+    end
+
+    puts "Please bounce the server."
+    gets
+
+    # Here we reconnect.
+    begin
+      @db1['stuff'].find.to_a
+      rescue Mongo::ConnectionFailure
+    end
+
+    threaded_exec do
+      assert @db1['stuff'].insert({:a => 2}, :safe => true)
+    end
+
+    threaded_exec do
+      assert @db2['stuff'].insert({:a => 2}, :safe => true)
+    end
+
+    @db1.logout
+    threaded_exec do
+      assert_raise Mongo::OperationFailure do
+        @db1['stuff'].insert({:a => 2}, :safe => true)
+      end
+    end
+
+    @db2.logout
+    threaded_exec do
+      assert_raise Mongo::OperationFailure do
+        assert @db2['stuff'].insert({:a => 2}, :safe => true)
+      end
+    end
+  end
+
+end