mongo 1.3.0 → 1.12.5

data/test/auxillary/1.4_features.rb

@@ -1,166 +0,0 @@
-$:.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

@@ -1,68 +0,0 @@
-$:.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

@@ -1,41 +0,0 @@
-$:.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

@@ -1,30 +0,0 @@
-$:.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

@@ -1,58 +0,0 @@
-$:.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

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

@@ -1,101 +0,0 @@
-$:.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

data/test/bson/binary_test.rb

@@ -1,15 +0,0 @@
-# encoding:utf-8
-require './test/test_helper'
-
-class BinaryTest < Test::Unit::TestCase
-  context "Inspecting" do
-    setup do
-      @data = ("THIS IS BINARY " * 50).unpack("c*")
-    end
-
-    should "not display actual data" do
-      binary = BSON::Binary.new(@data)
-      assert_equal "<BSON::Binary:#{binary.object_id}>", binary.inspect
-    end
-  end
-end