Example #1
0
def validate_auth_mechanism(dummy, value):
    """Validate the authMechanism URI option.
    """
    try:
        return MECHANISMS.index(value)
    except ValueError:
        raise ConfigurationError("%s is not a supported "
                                 "value for authMechanism" % (value,))
    def test_split_options(self):
        self.assertRaises(ConfigurationError, split_options, 'foo')
        self.assertRaises(ConfigurationError, split_options, 'foo=bar')
        self.assertRaises(ConfigurationError, split_options, 'foo=bar;foo')
        self.assertRaises(ConfigurationError, split_options, 'socketTimeoutMS=foo')
        self.assertRaises(ConfigurationError, split_options, 'socketTimeoutMS=0.0')
        self.assertRaises(ConfigurationError, split_options, 'connectTimeoutMS=foo')
        self.assertRaises(ConfigurationError, split_options, 'connectTimeoutMS=0.0')
        self.assertRaises(ConfigurationError, split_options, 'connectTimeoutMS=1e100000')
        self.assertRaises(ConfigurationError, split_options, 'connectTimeoutMS=-1e100000')

        # On most platforms float('inf') and float('-inf') represent
        # +/- infinity, although on Python 2.4 and 2.5 on Windows those
        # expressions are invalid
        if not (sys.platform == "win32" and sys.version_info <= (2, 5)):
            self.assertRaises(ConfigurationError, split_options, 'connectTimeoutMS=inf')
            self.assertRaises(ConfigurationError, split_options, 'connectTimeoutMS=-inf')

        self.assertTrue(split_options('socketTimeoutMS=300'))
        self.assertTrue(split_options('connectTimeoutMS=300'))
        self.assertEqual({'sockettimeoutms': 0.3}, split_options('socketTimeoutMS=300'))
        self.assertEqual({'sockettimeoutms': 0.0001}, split_options('socketTimeoutMS=0.1'))
        self.assertEqual({'connecttimeoutms': 0.3}, split_options('connectTimeoutMS=300'))
        self.assertEqual({'connecttimeoutms': 0.0001}, split_options('connectTimeoutMS=0.1'))
        self.assertTrue(split_options('connectTimeoutMS=300'))
        self.assertTrue(isinstance(split_options('w=5')['w'], int))
        self.assertTrue(isinstance(split_options('w=5.5')['w'], basestring))
        self.assertTrue(split_options('w=foo'))
        self.assertTrue(split_options('w=majority'))
        self.assertRaises(ConfigurationError, split_options, 'wtimeoutms=foo')
        self.assertRaises(ConfigurationError, split_options, 'wtimeoutms=5.5')
        self.assertTrue(split_options('wtimeoutms=500'))
        self.assertRaises(ConfigurationError, split_options, 'fsync=foo')
        self.assertRaises(ConfigurationError, split_options, 'fsync=5.5')
        self.assertEqual({'fsync': True}, split_options('fsync=true'))
        self.assertEqual({'fsync': False}, split_options('fsync=false'))
        self.assertEqual({'authmechanism': MECHANISMS.index('GSSAPI')},
                         split_options('authMechanism=GSSAPI'))
        self.assertEqual({'authmechanism': MECHANISMS.index('MONGO-CR')},
                         split_options('authMechanism=MONGO-CR'))
        self.assertEqual({'authsource': 'foobar'}, split_options('authSource=foobar'))
        # maxPoolSize isn't yet a documented URI option.
        self.assertRaises(ConfigurationError, split_options, 'maxpoolsize=50')
    def test_parse_uri(self):
        self.assertRaises(InvalidURI, parse_uri, "http://foobar.com")
        self.assertRaises(InvalidURI, parse_uri, "http://[email protected]")
        self.assertRaises(ConfigurationError,
                          parse_uri, "mongodb://::1", 27017)

        orig = {
            'nodelist': [("localhost", 27017)],
            'username': None,
            'password': None,
            'database': None,
            'collection': None,
            'options': {}
        }

        res = copy.deepcopy(orig)
        self.assertEqual(res, parse_uri("mongodb://localhost"))

        res.update({'username': '******', 'password': '******'})
        self.assertEqual(res, parse_uri("mongodb://*****:*****@localhost"))

        res.update({'database': 'baz'})
        self.assertEqual(res, parse_uri("mongodb://*****:*****@localhost/baz"))

        res = copy.deepcopy(orig)
        res['nodelist'] = [("example1.com", 27017), ("example2.com", 27017)]
        self.assertEqual(res,
                         parse_uri("mongodb://example1.com:27017,"
                                   "example2.com:27017"))

        res = copy.deepcopy(orig)
        res['nodelist'] = [("localhost", 27017),
                           ("localhost", 27018),
                           ("localhost", 27019)]
        self.assertEqual(res,
                         parse_uri("mongodb://localhost,"
                                   "localhost:27018,localhost:27019"))

        res = copy.deepcopy(orig)
        res['database'] = 'foo'
        self.assertEqual(res, parse_uri("mongodb://localhost/foo"))

        res = copy.deepcopy(orig)
        self.assertEqual(res, parse_uri("mongodb://localhost/"))

        res.update({'database': 'test', 'collection': 'yield_historical.in'})
        self.assertEqual(res, parse_uri("mongodb://"
                                        "localhost/test.yield_historical.in"))

        res.update({'username': '******', 'password': '******'})
        self.assertEqual(res,
                         parse_uri("mongodb://*****:*****@localhost/"
                                   "test.yield_historical.in"))

        res = copy.deepcopy(orig)
        res['nodelist'] = [("example1.com", 27017), ("example2.com", 27017)]
        res.update({'database': 'test', 'collection': 'yield_historical.in'})
        self.assertEqual(res,
                         parse_uri("mongodb://example1.com:27017,example2.com"
                                   ":27017/test.yield_historical.in"))

        res = copy.deepcopy(orig)
        res['nodelist'] = [("::1", 27017)]
        res['options'] = {'slaveok': True}
        self.assertEqual(res, parse_uri("mongodb://[::1]:27017/?slaveOk=true"))

        res = copy.deepcopy(orig)
        res['nodelist'] = [("2001:0db8:85a3:0000:0000:8a2e:0370:7334", 27017)]
        res['options'] = {'slaveok': True}
        self.assertEqual(res, parse_uri(
                              "mongodb://[2001:0db8:85a3:0000:0000"
                              ":8a2e:0370:7334]:27017/?slaveOk=true"))

        res = copy.deepcopy(orig)
        res['nodelist'] = [("/tmp/mongodb-27017.sock", None)]
        self.assertEqual(res, parse_uri("mongodb:///tmp/mongodb-27017.sock"))

        res = copy.deepcopy(orig)
        res['nodelist'] = [("example2.com", 27017),
                           ("/tmp/mongodb-27017.sock", None)]
        self.assertEqual(res,
                         parse_uri("mongodb://example2.com,"
                                   "/tmp/mongodb-27017.sock"))

        res = copy.deepcopy(orig)
        res['nodelist'] = [("shoe.sock.pants.co.uk", 27017),
                           ("/tmp/mongodb-27017.sock", None)]
        res['database'] = "nethers_db"
        self.assertEqual(res,
                         parse_uri("mongodb://shoe.sock.pants.co.uk,"
                                   "/tmp/mongodb-27017.sock/nethers_db"))

        res = copy.deepcopy(orig)
        res['nodelist'] = [("/tmp/mongodb-27017.sock", None),
                           ("example2.com", 27017)]
        res.update({'database': 'test', 'collection': 'yield_historical.in'})
        self.assertEqual(res,
                         parse_uri("mongodb:///tmp/mongodb-27017.sock,"
                                   "example2.com:27017"
                                   "/test.yield_historical.in"))

        res = copy.deepcopy(orig)
        res['nodelist'] = [("/tmp/mongodb-27017.sock", None),
                           ("example2.com", 27017)]
        res.update({'database': 'test', 'collection': 'yield_historical.sock'})
        self.assertEqual(res,
                         parse_uri("mongodb:///tmp/mongodb-27017.sock,"
                                   "example2.com:27017"
                                   "/test.yield_historical.sock"))

        res = copy.deepcopy(orig)
        res['nodelist'] = [("example2.com", 27017)]
        res.update({'database': 'test', 'collection': 'yield_historical.sock'})
        self.assertEqual(res,
                         parse_uri("mongodb://example2.com:27017"
                                   "/test.yield_historical.sock"))

        res = copy.deepcopy(orig)
        res['nodelist'] = [("/tmp/mongodb-27017.sock", None)]
        res.update({'database': 'test', 'collection': 'mongodb-27017.sock'})
        self.assertEqual(res,
                         parse_uri("mongodb:///tmp/mongodb-27017.sock"
                                   "/test.mongodb-27017.sock"))

        res = copy.deepcopy(orig)
        res['nodelist'] = [('/tmp/mongodb-27020.sock', None),
                           ("::1", 27017),
                           ("2001:0db8:85a3:0000:0000:8a2e:0370:7334", 27018),
                           ("192.168.0.212", 27019),
                           ("localhost", 27018)]
        self.assertEqual(res, parse_uri("mongodb:///tmp/mongodb-27020.sock,"
                                        "[::1]:27017,[2001:0db8:"
                                        "85a3:0000:0000:8a2e:0370:7334],"
                                        "192.168.0.212:27019,localhost",
                                        27018))

        res = copy.deepcopy(orig)
        res.update({'username': '******', 'password': '******'})
        res.update({'database': 'test', 'collection': 'yield_historical.in'})
        res['options'] = {'slaveok': True}
        self.assertEqual(res,
                         parse_uri("mongodb://*****:*****@localhost/"
                                   "test.yield_historical.in?slaveok=true"))

        res = copy.deepcopy(orig)
        res['options'] = {'readpreference': ReadPreference.SECONDARY}
        self.assertEqual(res,
                         parse_uri("mongodb://localhost/?readPreference=secondary"))

        # Various authentication tests
        res = copy.deepcopy(orig)
        res['options'] = {'authmechanism': MECHANISMS.index('MONGO-CR')}
        res['username'] = '******'
        res['password'] = '******'
        self.assertEqual(res,
                         parse_uri("mongodb://*****:*****@localhost/"
                                   "?authMechanism=MONGO-CR"))

        res = copy.deepcopy(orig)
        res['options'] = {'authmechanism': MECHANISMS.index('MONGO-CR'),
                          'authsource': 'bar'}
        res['username'] = '******'
        res['password'] = '******'
        res['database'] = 'foo'
        self.assertEqual(res,
                         parse_uri("mongodb://*****:*****@localhost/foo"
                                   "?authSource=bar;authMechanism=MONGO-CR"))

        res = copy.deepcopy(orig)
        res['options'] = {'authmechanism': MECHANISMS.index('MONGO-CR')}
        res['username'] = '******'
        res['password'] = ''
        self.assertEqual(res,
                         parse_uri("mongodb://user:@localhost/"
                                   "?authMechanism=MONGO-CR"))

        res = copy.deepcopy(orig)
        res['username'] = '******'
        res['password'] = '******'
        res['database'] = 'foo'
        self.assertEqual(res,
                         parse_uri("mongodb://user%40domain.com:password"
                                   "@localhost/foo"))

        res = copy.deepcopy(orig)
        res['options'] = {'authmechanism': MECHANISMS.index('GSSAPI')}
        res['username'] = '******'
        res['password'] = '******'
        res['database'] = 'foo'
        self.assertEqual(res,
                         parse_uri("mongodb://user%40domain.com:password"
                                   "@localhost/foo?authMechanism=GSSAPI"))

        res = copy.deepcopy(orig)
        res['options'] = {'authmechanism': MECHANISMS.index('GSSAPI')}
        res['username'] = '******'
        res['password'] = ''
        res['database'] = 'foo'
        self.assertEqual(res,
                         parse_uri("mongodb://user%40domain.com"
                                   "@localhost/foo?authMechanism=GSSAPI"))