class TestMixedVersionSharded(unittest.TestCase): def setup_server(self, upgrade): self.mongos_old, self.mongos_new = MockupDB(), MockupDB() # Collect queries to either server in one queue. self.q = Queue() for server in self.mongos_old, self.mongos_new: server.subscribe(self.q.put) server.autoresponds('getlasterror') server.run() self.addCleanup(server.stop) # Max wire version is too old for the upgraded operation. self.mongos_old.autoresponds('ismaster', ismaster=True, msg='isdbgrid', maxWireVersion=upgrade.wire_version - 1) # Up-to-date max wire version. self.mongos_new.autoresponds('ismaster', ismaster=True, msg='isdbgrid', maxWireVersion=upgrade.wire_version) self.mongoses_uri = 'mongodb://%s,%s' % (self.mongos_old.address_string, self.mongos_new.address_string) self.client = MongoClient(self.mongoses_uri) def tearDown(self): if hasattr(self, 'client') and self.client: self.client.close()
class TestGet(unittest.TestCase): @classmethod def setUp(self): self.server = MockupDB(auto_ismaster=True, verbose=True) self.server.run() app.testing = True app.config['MONGO_URI'] = self.server.uri self.client = app.test_client() @classmethod def tearDown(self): self.server.stop() # os.close(self.db_fd) # os.unlink(app.config['MONGO_URI']) @classmethod def test_getlist(self): document = DOCUMENT future = go(self.client.get, '/api/robot') request = self.server.receives() request.reply(document) http_response = future() data = http_response.get_data(as_text=True) self.assertIn('not_a_robot', data) self.assertIn('kawada-hironx', data)
def test_rsghost(self): rsother_response = { 'ok': 1.0, 'ismaster': False, 'secondary': False, 'info': 'Does not have a valid replica set config', 'isreplicaset': True, 'maxBsonObjectSize': 16777216, 'maxMessageSizeBytes': 48000000, 'maxWriteBatchSize': 100000, 'localTime': datetime.datetime(2021, 11, 30, 0, 53, 4, 99000), 'logicalSessionTimeoutMinutes': 30, 'connectionId': 3, 'minWireVersion': 0, 'maxWireVersion': 15, 'readOnly': False } server = MockupDB(auto_ismaster=rsother_response) server.run() self.addCleanup(server.stop) # Default auto discovery yields a server selection timeout. with MongoClient(server.uri, serverSelectionTimeoutMS=250) as client: with self.assertRaises(ServerSelectionTimeoutError): client.test.command('ping') # Direct connection succeeds. with MongoClient(server.uri, directConnection=True) as client: with going(client.test.command, 'ping'): request = server.receives(ping=1) request.reply()
def test_ssl_uri(self): server = MockupDB(ssl=True) server.run() self.addCleanup(server.stop) self.assertEqual( 'mongodb://localhost:%d/?ssl=true' % server.port, server.uri)
def setUp(self): self.server = MockupDB(auto_ismaster=True) self.server.run() self.addCleanup(self.server.stop) self.client = MongoClient(self.server.uri) self.collection = self.client.db.get_collection( 'collection', write_concern=WriteConcern(w=0))
def test_auto_dequeue(self): server = MockupDB(auto_ismaster=True) server.run() client = MongoClient(server.uri) future = go(client.admin.command, 'ping') server.autoresponds('ping') # Should dequeue the request. future()
def test_autoresponds_case_insensitive(self): server = MockupDB() # Little M. Note this is only case-insensitive because it's a Command. server.autoresponds(Command('ismaster'), foo='bar') server.run() response = MongoClient(server.uri).admin.command('isMaster') # Big M. self.assertEqual('bar', response['foo'])
def test_default_wire_version(self): server = MockupDB(auto_ismaster=True) server.run() self.addCleanup(server.stop) ismaster = MongoClient(server.uri).admin.command('isMaster') self.assertEqual(ismaster['minWireVersion'], 0) self.assertEqual(ismaster['maxWireVersion'], 6)
def test_iteration(self): server = MockupDB(auto_ismaster={'maxWireVersion': 3}) server.run() self.addCleanup(server.stop) client = MongoClient(server.uri) def send_three_docs(): for i in range(3): client.test.test.insert({'_id': i}) with going(send_three_docs): j = 0 # The "for request in server" statement is the point of this test. for request in server: self.assertTrue( request.matches({ 'insert': 'test', 'documents': [{ '_id': j }] })) request.ok() j += 1 if j == 3: break
def mocked_mongo(self): try: self.server = MockupDB(auto_ismaster={"maxWireVersion": 3}) self.server.run() yield finally: self.server.stop()
def test_projection(self): q = {} fields = {'foo': True} # OP_QUERY, server = MockupDB(auto_ismaster=True, min_wire_version=0, max_wire_version=3) server.run() self.addCleanup(server.stop) client = MongoClient(server.uri) cursor = client.test.collection.find(q, fields) with going(next, cursor): request = server.receives(OpQuery(q, fields=fields)) request.reply([], cursor_id=0) # "find" command. server = MockupDB(auto_ismaster=True, min_wire_version=0, max_wire_version=4) server.run() self.addCleanup(server.stop) client = MongoClient(server.uri) cursor = client.test.collection.find(q, fields) cmd = Command( SON([('find', 'collection'), ('filter', q), ('projection', fields)])) with going(next, cursor): request = server.receives(cmd) request.ok(cursor={'id': 0, 'firstBatch': []})
def test_getmore_sharded(self): servers = [MockupDB(), MockupDB()] # Collect queries to either server in one queue. q = Queue() for server in servers: server.subscribe(q.put) server.autoresponds('ismaster', ismaster=True, msg='isdbgrid') server.run() self.addCleanup(server.stop) client = MongoClient('mongodb://%s:%d,%s:%d' % (servers[0].host, servers[0].port, servers[1].host, servers[1].port)) self.addCleanup(client.close) collection = client.db.collection cursor = collection.find() with going(next, cursor): query = q.get(timeout=1) query.replies({}, cursor_id=123) # 10 batches, all getMores go to same server. for i in range(1, 10): with going(next, cursor): getmore = q.get(timeout=1) self.assertEqual(query.server, getmore.server) getmore.replies({}, starting_from=i, cursor_id=123)
class TestObjectCreation(unittest.TestCase): def setUp(self): app.config['TESTING'] = True app.config['WTF_CSRF_ENABLED'] = False app.config['DEBUG'] = False self.app = app.test_client() app.config['MONGO_URI'] = environ.get('MONGO_URI') self.app = app.test_client() self.server = MockupDB(auto_ismaster=True, verbose=True) self.server.run() def tearDown(self): pass #Check the valid values in Gender variable def test_valid_gender_values(self): stu_col1=stu_col.find({}) for i in stu_col1: self.assertIn(i['Gender'],'M|F') #Check the valid values in Predicted grade variable def test_valid_predicted_class_values(self): stu_col1=stu_col.find({}) for i in stu_col1: self.assertIn(i['Class'],'L|M|H') #Check the functioning of Home Page def test_home_page(self): response=self.app.get('/index') self.assertEqual(response.status_code,200) #Check the functioning of "All Students Page def test_view(self): response=self.app.get('/list') self.assertEqual(response.status_code,200)
def create_app(self): app.config.from_object('project.config.TestingConfig') self.server = MockupDB(auto_ismaster=True) self.server.run() app.config['MONGO_URI'] = self.server.uri mongo.init_app(app) return app
def client_server(self, *args, **kwargs): server = MockupDB(*args, **kwargs) server.run() self.addCleanup(server.stop) client = motor_asyncio.AsyncIOMotorClient(server.uri, io_loop=self.loop) return client, server
def setUpClass(self): self.server = MockupDB(auto_ismaster=True, verbose=True) self.server.run() # create mongo connection to mock server app.app.testing = True app.app.config['MONGO_URI'] = self.server.uri self.app = app.app.test_client()
def setUpClass(self) -> None: self.server = MockupDB(auto_ismaster=True, verbose=True) self.server.run() Config.MONGO_URI = self.server.uri app = create_app() self.app = app.test_client()
def setUp(self): app.config['TESTING'] = True app.config['WTF_CSRF_ENABLED'] = False app.config['DEBUG'] = False self.app = app.test_client() app.config['MONGO_URI'] = environ.get('MONGO_URI') self.app = app.test_client() self.server = MockupDB(auto_ismaster=True, verbose=True) self.server.run()
def client_server(self, *args, **kwargs): server = MockupDB(*args, **kwargs) server.run() self.addCleanup(server.stop) client = motor.motor_tornado.MotorClient(server.uri, io_loop=self.io_loop) return client, server
def setUp(self): ''' Set up test fixtures ''' self.user = '******' self.email = '*****@*****.**' self.building = 'test_building' self.image_path = os.path.join(os.environ.get('FULL_IMAGE_DIR'), 'MooreHall_1.jpg') self.server = MockupDB(auto_ismaster={"maxWireVersion": 6}) self.server.run() self.app = app.create_test_app(self.server.uri).test_client()
def setUp(self): self.server = MockupDB(auto_ismaster={"maxWireVersion": 3}) self.server.run() #self.testConf['mongo_url'] = self.testConf = { "mongo_url" : self.server.uri, "host_url": "https://lmp.nupursjsu.net", "host" : "127.0.0.1", "port" : 8080 }
def setUp(self): """ Prepare the test envirement. start the server to mockup the database """ self.server = MockupDB(auto_ismaster=True, verbose=True) self.server.run() app.testing = True app.config['MONGO_URI'] = self.server.uri self.app = app.test_client()
def test_ok(self): server = MockupDB(auto_ismaster={'maxWireVersion': 3}) server.run() self.addCleanup(server.stop) client = MongoClient(server.uri) with going(client.test.command, {'foo': 1}) as future: server.receives().ok(3) response = future() self.assertEqual(3, response['ok'])
def setUp(self): """ Prepare the test envirement. start the server to mockup the database """ self.server = MockupDB(auto_ismaster=True, verbose=True) self.server.run() app.testing = True app.config['MONGO_URI'] = self.server.uri self.app = app.test_client() self.token = mock_access_token()['access_token'] self.auth_header = {'Authorization': 'Bearer {}'.format(self.token)}
def setup_server(self, wire_version): self.server = MockupDB() def responder(request): self.ismaster_time = time.time() return request.ok(ismaster=True, maxWireVersion=wire_version) self.server.autoresponds('ismaster', responder) self.server.run() self.addCleanup(self.server.stop) self.client = MongoClient(self.server.uri, socketTimeoutMS=100) wait_until(lambda: self.client.nodes, 'connect to standalone')
def setUp(self): self.loop = asyncio.new_event_loop() asyncio.set_event_loop(self.loop) self.server = MockupDB(auto_ismaster={"maxWireVersion": 6}) self.server.run() self.server.autoresponds( Command("find", "switch_collection", namespace="topology_database"), { "cursor": { "id": 0, "firstBatch": [{ **d, "_id": i } for i, d in enumerate(TOPOLOGY_DATABASE_DATA)], } }, ) self._stack = AsyncExitStack() td = self._stack.enter_context(tempfile.TemporaryDirectory()) self.rpc_unix_sock = os.path.join(td, "l.sock") self._stack.enter_context( patch.object(settings, "REMOTE_DATABASE_MONGO_URI", self.server.uri)) self._stack.enter_context( patch.object(settings, "NEGOTIATOR_RPC_UNIX_SOCK_PATH", self.rpc_unix_sock)) self._stack.enter_context( patch("agile_mesh_network.ryu.amn_manager.OVSManager", DummyOVSManager)) self._stack.enter_context( # To avoid automatic connection to a relay. patch.object(settings, "IS_RELAY", True)) self._stack.enter_context( patch.object(events_scheduler, "RyuAppEventLoopScheduler")) self.ryu_ev_loop_scheduler = events_scheduler.RyuAppEventLoopScheduler( ) self._stack.enter_context(self.ryu_ev_loop_scheduler) async def command_cb(session, msg): assert isinstance(msg, RPCCommand) await self._rpc_command_cb(msg) self.rpc_server = self.loop.run_until_complete( self._stack.enter_async_context( RPCUnixServer(self.rpc_unix_sock, command_cb)))
def test_aggregate(self): server = MockupDB() server.autoresponds('ismaster', ismaster=True, msg='isdbgrid', minWireVersion=2, maxWireVersion=6) self.addCleanup(server.stop) server.run() client = MongoClient(server.uri) self.addCleanup(client.close) collection = client.test.collection with going(collection.aggregate, []): command = server.receives(aggregate='collection', pipeline=[]) self.assertFalse(command.slave_ok, 'SlaveOkay set') command.ok(result=[{}]) secondary_collection = collection.with_options( read_preference=ReadPreference.SECONDARY) with going(secondary_collection.aggregate, []): command = server.receives(OpMsg({"aggregate": "collection", "pipeline": [], '$readPreference': {'mode': 'secondary'}})) command.ok(result=[{}]) self.assertTrue(command.slave_ok, 'SlaveOkay not set')
class BaseTestCase(TestCase): def create_app(self): app.config.from_object('project.config.TestingConfig') self.server = MockupDB(auto_ismaster=True) self.server.run() app.config['MONGO_URI'] = self.server.uri mongo.init_app(app) return app def setUp(self): pass def tearDown(self): self.server.stop()
def test_aggregate(self): server = MockupDB() server.autoresponds('ismaster', ismaster=True, msg='isdbgrid', minWireVersion=2, maxWireVersion=5) self.addCleanup(server.stop) server.run() client = MongoClient(server.uri) self.addCleanup(client.close) collection = client.test.collection with going(collection.aggregate, []): command = server.receives(aggregate='collection', pipeline=[]) self.assertFalse(command.slave_ok, 'SlaveOkay set') self.assertNotIn('$readPreference', command) command.ok(result=[{}]) secondary_collection = collection.with_options( read_preference=ReadPreference.SECONDARY) with going(secondary_collection.aggregate, []): command = server.receives({ '$query': SON([('aggregate', 'collection'), ('pipeline', []), ('cursor', {})]), '$readPreference': { 'mode': 'secondary' } }) command.ok(result=[{}]) self.assertTrue(command.slave_ok, 'SlaveOkay not set')
def setup_server(self, wire_version): self.mongos1, self.mongos2 = MockupDB(), MockupDB() # Collect queries to either server in one queue. self.q = Queue() for server in self.mongos1, self.mongos2: server.subscribe(self.q.put) server.run() self.addCleanup(server.stop) server.autoresponds('ismaster', maxWireVersion=wire_version, ismaster=True, msg='isdbgrid') self.mongoses_uri = 'mongodb://%s,%s' % (self.mongos1.address_string, self.mongos2.address_string)
class BaseTestCase(unittest.TestCase): server = None @classmethod def setUpClass(self): self.server = MockupDB(auto_ismaster=True, verbose=True) self.server.run() # create mongo connection to mock server app.app.testing = True app.app.config['MONGO_URI'] = self.server.uri self.app = app.app.test_client() @classmethod def tearDownClass(self): self.server.stop() def test_getDataSources(self): # arrange future = go(self.app.get, '/dataSources') request = self.server.receives( Command({ 'find': 'dataSources', 'filter': {} }, flags=4, namespace='app')) request.ok( cursor={ 'id': 0, 'firstBatch': [{ 'name': 'Google', 'url': 'http://google.com/rest/api' }, { 'name': 'Rest', 'url': 'http://rest.com/rest/api' }] }) # act http_response = future() # assert data = http_response.get_data(as_text=True) self.assertIn('http://google.com/rest/api', data) self.assertIn('http://rest.com/rest/api', data)
def test(self): server = MockupDB() self.addCleanup(server.stop) server.run() server.autoresponds('ismaster', ismaster=True, msg='isdbgrid', minWireVersion=2, maxWireVersion=6) pref = make_read_preference(read_pref_mode_from_name(mode), tag_sets=None) client = MongoClient(server.uri, read_preference=pref) self.addCleanup(client.close) with going(operation.function, client): request = server.receive() request.reply(operation.reply) if operation.op_type == 'always-use-secondary': self.assertEqual(ReadPreference.SECONDARY.document, request.doc.get('$readPreference')) slave_ok = mode != 'primary' elif operation.op_type == 'must-use-primary': slave_ok = False elif operation.op_type == 'may-use-secondary': slave_ok = mode != 'primary' self.assertEqual(pref.document, request.doc.get('$readPreference')) else: self.fail('unrecognized op_type %r' % operation.op_type) if slave_ok: self.assertTrue(request.slave_ok, 'SlaveOkay not set') else: self.assertFalse(request.slave_ok, 'SlaveOkay set')
def test_query_and_read_mode_sharded_op_msg(self): """Test OP_MSG sends non-primary $readPreference and never $query.""" server = MockupDB() server.autoresponds('ismaster', ismaster=True, msg='isdbgrid', minWireVersion=2, maxWireVersion=6) server.run() self.addCleanup(server.stop) client = MongoClient(server.uri) self.addCleanup(client.close) read_prefs = ( Primary(), SecondaryPreferred(), PrimaryPreferred(), Secondary(), Nearest(), SecondaryPreferred([{'tag': 'value'}]),) for query in ({'a': 1}, {'$query': {'a': 1}},): for mode in read_prefs: collection = client.db.get_collection('test', read_preference=mode) cursor = collection.find(query.copy()) with going(next, cursor): request = server.receives() # Command is not nested in $query. request.assert_matches(OpMsg( SON([('find', 'test'), ('filter', {'a': 1}), ('$readPreference', mode.document)]))) request.replies({'cursor': {'id': 0, 'firstBatch': [{}]}})
def setup_server(self): self.server = MockupDB() def responder(request): self.ismaster_time = time.time() return request.ok(ismaster=True, minWireVersion=2, maxWireVersion=6) self.server.autoresponds('ismaster', responder) self.server.run() self.addCleanup(self.server.stop) kwargs = {'socketTimeoutMS': 100} # Disable retryable reads when pymongo supports it. kwargs['retryReads'] = False self.client = MongoClient(self.server.uri, **kwargs) wait_until(lambda: self.client.nodes, 'connect to standalone')
def test_iteration(self): server = MockupDB(auto_ismaster={'maxWireVersion': 3}) server.run() self.addCleanup(server.stop) client = MongoClient(server.uri) def send_three_docs(): for i in range(3): client.test.test.insert({'_id': i}) with going(send_three_docs): j = 0 # The "for request in server" statement is the point of this test. for request in server: self.assertTrue(request.matches({'insert': 'test', 'documents': [{'_id': j}]})) request.ok() j += 1 if j == 3: break
def test_ssl_basic(self): server = MockupDB(ssl=True, auto_ismaster=True) server.run() self.addCleanup(server.stop) client = MongoClient(server.uri, ssl_cert_reqs=ssl.CERT_NONE) client.db.command('ismaster')
def setUp(self): self.server = MockupDB(auto_ismaster=True) self.server.run() self.addCleanup(self.server.stop) self.client = MongoClient(self.server.uri) self.collection = self.client.db.collection
def server(self, *args, **kwargs): server = MockupDB(*args, **kwargs) server.run() self.addCleanup(server.stop) return server
class TestLegacyWrites(unittest.TestCase): def setUp(self): self.server = MockupDB(auto_ismaster=True) self.server.run() self.addCleanup(self.server.stop) self.client = MongoClient(self.server.uri) self.collection = self.client.db.collection def test_insert_one(self): with going(self.collection.insert_one, {'_id': 1}) as future: self.server.receives(OpInsert({'_id': 1}, flags=0)) self.server.receives(Command('getlasterror')).replies_to_gle() self.assertEqual(1, future().inserted_id) def test_insert_many(self): collection = self.collection.with_options( write_concern=WriteConcern(0)) flags = INSERT_FLAGS['ContinueOnError'] docs = [{'_id': 1}, {'_id': 2}] with going(collection.insert_many, docs, ordered=False) as future: self.server.receives(OpInsert(docs, flags=flags)) self.assertEqual([1, 2], future().inserted_ids) def test_replace_one(self): with going(self.collection.replace_one, {}, {}) as future: self.server.receives(OpUpdate({}, {}, flags=0)) request = self.server.receives(Command('getlasterror')) request.replies_to_gle(upserted=1) self.assertEqual(1, future().upserted_id) def test_update_many(self): flags = UPDATE_FLAGS['MultiUpdate'] with going(self.collection.update_many, {}, {'$unset': 'a'}) as future: update = self.server.receives(OpUpdate({}, {}, flags=flags)) self.assertEqual(2, update.flags) gle = self.server.receives(Command('getlasterror')) gle.replies_to_gle(upserted=1) self.assertEqual(1, future().upserted_id) def test_delete_one(self): flags = DELETE_FLAGS['SingleRemove'] with going(self.collection.delete_one, {}) as future: delete = self.server.receives(OpDelete({}, flags=flags)) self.assertEqual(1, delete.flags) gle = self.server.receives(Command('getlasterror')) gle.replies_to_gle(n=1) self.assertEqual(1, future().deleted_count) def test_delete_many(self): with going(self.collection.delete_many, {}) as future: delete = self.server.receives(OpDelete({}, flags=0)) self.assertEqual(0, delete.flags) gle = self.server.receives(Command('getlasterror')) gle.replies_to_gle(n=2) self.assertEqual(2, future().deleted_count)