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 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):
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)
