def __init__(self, db="foo", **kwargs):
from mongomock import MongoClient
self._client = MongoClient()
self._db = getattr(self._client, db)
# note: don't call superclass!
self._database_name = db
self._server_url = "mock"
def __init__(self):
# Client & Database
self.client = MongoClient("mongodb://mongo:27017/")
self.db = self.client["nautilus"]
# Collections
self.profiles = self.db["profiles"]
def setUp(self):
"""Test setup upon each run"""
# Creating user instance
values = {
'grocery': 10000,
'utilities': 20000,
'transportation': 5000,
'salary': 200000,
'equities': 20000,
'pension': 20000,
'emergency': 20000
}
self.user = create_user_dict('Dominic', 'Henry', values)
self.user['ipAddress'] = '192.0.1.20'
# Adding expected generated report entries
self.user.update({
'totalExpenses': 35000,
'totalSavings': 60000,
'totalIncome': 200000,
'leftover': 105000,
'statement': 'You have a good handle of your budget'
})
# Instantiate MongoClient
# Inserting new user instance into mock mongodb database
self.mongo_client = MongoClient()
self.user_collection = self.mongo_client.db.user
self.user_collection.insert_one(self.user)
def db_client(*args, **kwargs):
client = MongoClient()
db = client.get_database("conversation")
conversations = db.get_collection("conversations")
history, _ = self.history_conversations()
conversations.insert_many(history)
return client, "conversation", "conversations", None
def db_client(*args, **kwargs):
client = MongoClient(Utility.environment['tracker']['url'])
db = client.get_database("conversation")
conversations = db.get_collection("conversations")
history, _ = self.history_conversations()
conversations.insert_many(history)
return client, 'Loading host:mongodb://test_kairon:27016, db:conversation, collection:conversations'
def app():
app = create_app('buscabike')
app.db = MongoClient().db
ads_fixture_data(app.db)
return app
def _prepare_test_app():
app = create_app()
app.db = MongoClient().db
ads_fixture_data(app.db)
return app
def test_cif_to_dict(db, kwargs):
client = MongoClient()
coll = client.db.coll
dcts = cif_to_dict(db["Ni_stru_file"], **kwargs)
for dct in dcts:
pprint(dct)
# test mongo friendly
coll.insert_one(dct)
def __init__(self, _domain: Domain):
from mongomock import MongoClient
self.db = MongoClient().rasa
self.collection = "conversations"
# Skip `MongoTrackerStore` constructor to avoid that actual Mongo connection
# is created.
super(MongoTrackerStore, self).__init__(_domain, None)
def __init__(
self,
_domain: Domain,
):
from mongomock import MongoClient
self.db = MongoClient().rasa
self.collection = "conversations"
super(MongoTrackerStore, self).__init__(_domain, None)
def mongo_client():
mc = MongoClient()
col: Collection = mc.channels_bot.telegram_resources
col.insert_many([{
"_id": 1067810422,
"name": "popyachsa",
"recent_post_id": 39582
}])
yield mc
mc.drop_database("channels_bot")
def pymongo_client(request):
"""Get a client to the mongo database"""
mock_client = MongoClient()
def teardown():
mock_client.drop_database(DATABASE)
request.addfinalizer(teardown)
return mock_client
def setUp(self):
self.cli = MongoClient()
self.db = self.cli.test
model.metadata.bind(self.db)
@task('test')
def func():
pass
self.func = func
def test_get_articles_default_start():
collection = MongoClient().db.collection
collection.insert_many([{
'_id': 'tw:abc',
'label': 's***e',
'added': datetime.utcnow()
}, {
'_id': 'ge:boo',
'added': datetime(1971, 1, 1)
}])
assert len(list(get_articles(collection))) == 2
def _get_manager(self):
"""
A provisioned mock collection for testing
"""
self.collection = MongoClient().db.collection
self.collection.insert(copy(self.redirect_one))
self.collection.insert(copy(self.redirect_two))
self.collection.insert(copy(self.redirect_three))
return RedirectManager(self.collection)
def mockmongoclient(item_info: Dict[str, Any]):
with patch('happi.backends.mongo_db.MongoClient') as mock_mongo:
mc = MongoClient()
mc['test_db'].create_collection('test_collect')
mock_mongo.return_value = mc
# Client
backend = MongoBackend(db='test_db', collection='test_collect')
client = Client(database=backend)
# Insert a single device
client.backend._collection.insert_one(item_info)
return client
def __init__(self, host='localhost', port=27017, db_name='test'):
client = MongoClient()
self.config = {}
self.extensions = {'pymongo': {}}
self.config['MONGO_DBNAME'] = db_name
self.config['MONGO_PORT'] = port
self.config['MONGO_HOST'] = host
# This is how flaskpymongo sets it up:
self.extensions['pymongo']['MONGO'] = [client, client[db_name]]
def test_one_pronoun_local_wiktionary(self, mongo_db):
client = MongoClient()
db_name = 'pronunciation_master'
db = getattr(client, db_name)
mongo_db.return_value = db
collection = db.wiktionary_ipa
collection.insert_one({
'language': 'Dutch',
'word': 'bad',
'IPA': ['phoneme'],
})
self.assertEqual(self.fun('dutch', 'bad', local=db_name), ['phoneme'])
def __init__(self, host="localhost", port=27017, db_name="test"):
client = MongoClient()
self.config = {}
self.extensions = {"pymongo": {}}
self.config["MONGO_DBNAME"] = db_name
self.config["MONGO_PORT"] = port
self.config["MONGO_HOST"] = host
# This is how flaskpymongo sets it up:
self.extensions["pymongo"]["MONGO"] = [client, client[db_name]]
def test_get_articles_with_regex():
collection = MongoClient().db.collection
collection.insert_many([{
'_id': 'tw:abc',
'added': datetime.utcnow(),
'foo': 'bar'
}, {
'_id': 'ge:dbc',
'added': datetime.utcnow(),
'foo': 'bar'
}])
assert len(list(get_articles(collection, src='tw'))) == 1
assert len(list(get_articles(collection, src='ge'))) == 1
assert len(list(get_articles(collection))) == 2
def test_get_from_json(self):
test_object: dict = ToDoItem.new_item_as_dict(
"Testing static constructor method")
collection = MongoClient().db.collection
collection.insert_one(test_object)
returned_object = collection.find_one(
{'title': 'Testing static constructor method'})
object_to_test: ToDoItem = ToDoItem.from_json(returned_object)
assert isinstance(object_to_test.item_id, str)
assert "Testing static constructor method" == object_to_test.title
assert "To Do" == object_to_test.status
assert isinstance(object_to_test.last_modified, datetime)
def setUpClass(cls):
parser = LarkParser(version=(0, 9, 7))
transformer = MongoTransformer()
def convert(_, q):
parsed = parser.parse(q)
return transformer.transform(parsed)
cls.convert = convert
cls.client = MongoClient()
cls.db = cls.client[f"test_db_{uuid.uuid4()}"]
cls.coll = cls.db.data
cls.coll.insert_many([{
"a": a,
"b": b
} for a, b in itertools.product(range(10), range(10))])
def test_get_articles_with_label():
collection = MongoClient().db.collection
collection.insert_many([{
'_id': 'tw:abc',
'label': 's***e',
'added': datetime.utcnow()
}, {
'_id': 'ge:dbc',
'added': datetime.utcnow()
}, {
'_id': 'ge:boo',
'added': datetime.utcnow()
}])
assert len(list(get_articles(collection, False))) == 2
assert len(list(get_articles(collection, True))) == 1
assert len(list(get_articles(collection))) == 3
def __init__(
self,
_domain: Domain,
retrieve_events_from_previous_conversation_sessions: bool = False,
) -> None:
from mongomock import MongoClient
self.db = MongoClient().rasa
self.collection = "conversations"
self.retrieve_events_from_previous_conversation_sessions = (
retrieve_events_from_previous_conversation_sessions)
# skipcq: PYL-E1003
# Skip `MongoTrackerStore` constructor to avoid that actual Mongo connection
# is created.
super(MongoTrackerStore, self).__init__(_domain, None)
def pymongo_client(request):
"""Get a client to the mongo database"""
logger.info("Get a mongomock client")
start_time = datetime.datetime.now()
mock_client = MongoClient()
def teardown():
print('\n')
logger.info("Deleting database")
mock_client.drop_database(DATABASE)
logger.info("Database deleted")
logger.info("Time to run test:{}".format(datetime.datetime.now() - start_time))
request.addfinalizer(teardown)
return mock_client
def get_app(self):
application = tornado.web.Application([
(
r"/auth/login/dummy",
DummyLoginHandler,
dict(persistentUserListObj=PersistentUserList(MongoClient().test.reefwatch_user))
),
(r'/auth/success', LoginSuccessHandler),
(r'/auth/Logout', LogoutHandler),
(r'/requires_auth', RequiresAuthHandler),
(r'/', LogoutSuccessHandler)
]
)
application.settings = dict(
cookie_secret=self.__cookieSecret__,
login_url="/auth/login/dummy"
)
return application
def test_get_articles_up_to_is_strictly_greater():
date_from = datetime.now() - timedelta(weeks=1)
old_item = datetime.now() - timedelta(weeks=2)
collection = MongoClient().db.collection
collection.insert_many([{
'_id': 'tw:abc',
'label': 's***e',
'added': datetime.utcnow()
}, {
'_id': 'ge:boo',
'added': old_item
}])
assert len(list(get_articles(collection, date_start=old_item))) == 2
assert len(list(get_articles(collection, date_end=old_item))) == 0
assert len(
list(get_articles(collection, date_start=old_item,
date_end=date_from))) == 1
def new_log(self, update, funcname):
client = MongoClient("mongodb://localhost")
database = client.get_database("test-db")
database.create_collection("unittest")
database["unittest"].insert_one({
'user':
update.effective_user.first_name,
'user id':
update.message.chat.id,
'function':
funcname.name,
'message':
update.message.text,
'time':
datetime.now().strftime("%Y-%m-%d %H.%M")
})
result = database["unittest"].find_one()
del result['_id']
# print(result)
return result
def __init__(self, host="127.0.0.1", port=27017, database="vasp",
user=None, password=None, collection="tasks",
aliases_config=None, default_properties=None):
try:
QueryEngine.__init__(self, host=host, port=port, database=database,
user=user, password=password, collection=collection,
aliases_config=aliases_config,
default_properties=default_properties)
print("@@ connected to real Mongo")
return # actully connected! not mocked..
except:
pass
self.connection = MongoClient(self.host, self.port)
self.db = self.connection[database]
self._user, self._password = user, password
self.host = host
self.port = port
self.database_name = database
# colllection name is now a @property. the setter will set "self.collection" internally
self.collection_name = collection
self.set_aliases_and_defaults(aliases_config=aliases_config,
default_properties=default_properties)
def setUp(self):
self.mockCollection = MongoClient().db.collection
self.documents = [
# The house
{"location": {"lat": 51.600924, "lng": -0.323493},
"tubuleMember": True},
# Less than a mile away
{"location": {"lat": 51.604427, "lng": -0.341273},
"tubuleMember": True},
# 14 miles
{"location": {"lat": 51.540805, "lng": -0.094807}},
# less than 60 miles away
{"location": {"lat": 51.678257, "lng": 0.295109}},
# More than 100 miles away!
{"location": {"lat": 53.601497, "lng": -0.999597},
"tubuleMember": True}
]
for doc in self.documents:
self.mockCollection.insert(doc)
# Delete Object Ids of documents
for m in self.documents:
del m["_id"]
