def run_entity_operation(self, spec):
target = self.entity_map[spec['object']]
opname = spec['name']
opargs = spec.get('arguments')
expect_error = spec.get('expectError')
if opargs:
arguments = parse_spec_options(copy.deepcopy(opargs))
prepare_spec_arguments(spec, arguments, camel_to_snake(opname),
self.entity_map, self.run_operations)
else:
arguments = tuple()
if isinstance(target, MongoClient):
method_name = '_clientOperation_%s' % (opname, )
elif isinstance(target, Database):
method_name = '_databaseOperation_%s' % (opname, )
elif isinstance(target, Collection):
method_name = '_collectionOperation_%s' % (opname, )
elif isinstance(target, ChangeStream):
method_name = '_changeStreamOperation_%s' % (opname, )
elif isinstance(target, ClientSession):
method_name = '_sessionOperation_%s' % (opname, )
elif isinstance(target, GridFSBucket):
raise NotImplementedError
else:
method_name = 'doesNotExist'
try:
method = getattr(self, method_name)
except AttributeError:
try:
cmd = getattr(target, camel_to_snake(opname))
except AttributeError:
self.fail('Unsupported operation %s on entity %s' %
(opname, target))
else:
cmd = functools.partial(method, target)
try:
result = cmd(**dict(arguments))
except Exception as exc:
if expect_error:
return self.process_error(exc, expect_error)
raise
if 'expectResult' in spec:
self.match_evaluator.match_result(spec['expectResult'], result)
save_as_entity = spec.get('saveResultAsEntity')
if save_as_entity:
self.entity_map[save_as_entity] = result
def parse_options(opts):
return parse_spec_options(opts)
def _create_entity(self, entity_spec):
if len(entity_spec) != 1:
self._test_class.fail(
"Entity spec %s did not contain exactly one top-level key" %
(entity_spec, ))
entity_type, spec = next(iteritems(entity_spec))
if entity_type == 'client':
kwargs = {}
observe_events = spec.get('observeEvents', [])
ignore_commands = spec.get('ignoreCommandMonitoringEvents', [])
if len(observe_events) or len(ignore_commands):
ignore_commands = [cmd.lower() for cmd in ignore_commands]
listener = EventListenerUtil(observe_events, ignore_commands)
self._listeners[spec['id']] = listener
kwargs['event_listeners'] = [listener]
if client_context.is_mongos and spec.get('useMultipleMongoses'):
kwargs['h'] = client_context.mongos_seeds()
kwargs.update(spec.get('uriOptions', {}))
server_api = spec.get('serverApi')
if server_api:
kwargs['server_api'] = ServerApi(
server_api['version'],
strict=server_api.get('strict'),
deprecation_errors=server_api.get('deprecationErrors'))
client = rs_or_single_client(**kwargs)
self[spec['id']] = client
self._test_class.addCleanup(client.close)
return
elif entity_type == 'database':
client = self[spec['client']]
if not isinstance(client, MongoClient):
self._test_class.fail(
'Expected entity %s to be of type MongoClient, got %s' %
(spec['client'], type(client)))
options = parse_collection_or_database_options(
spec.get('databaseOptions', {}))
self[spec['id']] = client.get_database(spec['databaseName'],
**options)
return
elif entity_type == 'collection':
database = self[spec['database']]
if not isinstance(database, Database):
self._test_class.fail(
'Expected entity %s to be of type Database, got %s' %
(spec['database'], type(database)))
options = parse_collection_or_database_options(
spec.get('collectionOptions', {}))
self[spec['id']] = database.get_collection(spec['collectionName'],
**options)
return
elif entity_type == 'session':
client = self[spec['client']]
if not isinstance(client, MongoClient):
self._test_class.fail(
'Expected entity %s to be of type MongoClient, got %s' %
(spec['client'], type(client)))
opts = camel_to_snake_args(spec.get('sessionOptions', {}))
if 'default_transaction_options' in opts:
txn_opts = parse_spec_options(
opts['default_transaction_options'])
txn_opts = TransactionOptions(**txn_opts)
opts = copy.deepcopy(opts)
opts['default_transaction_options'] = txn_opts
session = client.start_session(**dict(opts))
self[spec['id']] = session
self._session_lsids[spec['id']] = copy.deepcopy(session.session_id)
self._test_class.addCleanup(session.end_session)
return
elif entity_type == 'bucket':
# TODO: implement the 'bucket' entity type
self._test_class.skipTest(
'GridFS is not currently supported (PYTHON-2459)')
self._test_class.fail('Unable to create entity of unknown type %s' %
(entity_type, ))
def run_entity_operation(self, spec):
target = self.entity_map[spec['object']]
opname = spec['name']
opargs = spec.get('arguments')
expect_error = spec.get('expectError')
save_as_entity = spec.get('saveResultAsEntity')
expect_result = spec.get('expectResult')
ignore = spec.get('ignoreResultAndError')
if ignore and (expect_error or save_as_entity or expect_result):
raise ValueError(
'ignoreResultAndError is incompatible with saveResultAsEntity'
', expectError, and expectResult')
if opargs:
arguments = parse_spec_options(copy.deepcopy(opargs))
prepare_spec_arguments(spec, arguments, camel_to_snake(opname),
self.entity_map, self.run_operations)
else:
arguments = tuple()
if isinstance(target, MongoClient):
method_name = '_clientOperation_%s' % (opname, )
elif isinstance(target, Database):
method_name = '_databaseOperation_%s' % (opname, )
elif isinstance(target, Collection):
method_name = '_collectionOperation_%s' % (opname, )
elif isinstance(target, ChangeStream):
method_name = '_changeStreamOperation_%s' % (opname, )
elif isinstance(target, NonLazyCursor):
method_name = '_cursor_%s' % (opname, )
elif isinstance(target, ClientSession):
method_name = '_sessionOperation_%s' % (opname, )
elif isinstance(target, GridFSBucket):
raise NotImplementedError
else:
method_name = 'doesNotExist'
try:
method = getattr(self, method_name)
except AttributeError:
try:
cmd = getattr(target, camel_to_snake(opname))
except AttributeError:
self.fail('Unsupported operation %s on entity %s' %
(opname, target))
else:
cmd = functools.partial(method, target)
try:
result = cmd(**dict(arguments))
except Exception as exc:
# Ignore all operation errors but to avoid masking bugs don't
# ignore things like TypeError and ValueError.
if ignore and isinstance(exc, (PyMongoError, )):
return
if expect_error:
return self.process_error(exc, expect_error)
raise
else:
if expect_error:
self.fail('Excepted error %s but "%s" succeeded: %s' %
(expect_error, opname, result))
if expect_result:
actual = coerce_result(opname, result)
self.match_evaluator.match_result(expect_result, actual)
if save_as_entity:
self.entity_map[save_as_entity] = result
